1 #![allow(non_upper_case_globals)]
2 #![allow(non_snake_case)]
3 #[allow(unused_imports)] use binder::IBinderInternal;
4 use binder::declare_binder_interface;
5 declare_binder_interface! {
6 ITestService["android.aidl.tests.ITestService"] {
7 native: BnTestService(on_transact),
8 proxy: BpTestService {
9 },
10 }
11 }
12 pub trait ITestService: binder::Interface + Send {
get_descriptor() -> &'static str where Self: Sized13 fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" }
UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32>14 fn UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32>;
15 #[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(&self) -> binder::public_api::Result<()>16 fn Deprecated(&self) -> binder::public_api::Result<()>;
TestOneway(&self) -> binder::public_api::Result<()>17 fn TestOneway(&self) -> binder::public_api::Result<()>;
RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool>18 fn RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool>;
RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8>19 fn RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8>;
RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16>20 fn RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16>;
RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32>21 fn RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32>;
RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64>22 fn RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64>;
RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32>23 fn RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32>;
RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64>24 fn RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64>;
RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String>25 fn RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String>;
RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>26 fn RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>;
RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>27 fn RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>;
RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>28 fn RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>;
ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>>29 fn ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>>;
ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>>30 fn ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>>;
ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>>31 fn ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>>;
ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>>32 fn ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>>;
ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>>33 fn ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>>;
ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>>34 fn ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>>;
ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>>35 fn ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>>;
ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>36 fn ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>;
ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>37 fn ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>;
ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>38 fn ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>;
ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>39 fn ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>;
GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>40 fn GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>;
VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool>41 fn VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool>;
ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>42 fn ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>;
RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor>43 fn RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor>;
ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>>44 fn ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>>;
ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()>45 fn ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()>;
RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>>46 fn RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>>;
RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>>47 fn RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>>;
RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>>48 fn RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>>;
RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>>49 fn RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>>;
RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>>50 fn RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>>;
RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>>51 fn RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>>;
RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>>52 fn RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>>;
TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()>53 fn TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()>;
TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()>54 fn TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()>;
RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String>55 fn RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String>;
RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>>56 fn RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>>;
ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>57 fn ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>;
ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>58 fn ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>;
ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>59 fn ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>;
GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>>60 fn GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>>;
FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()>61 fn FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()>;
GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>>62 fn GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>>;
GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>>63 fn GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>>;
GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>>64 fn GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>>;
getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType>65 fn getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType>;
getDefaultImpl() -> ITestServiceDefaultRef where Self: Sized66 fn getDefaultImpl() -> ITestServiceDefaultRef where Self: Sized {
67 DEFAULT_IMPL.lock().unwrap().clone()
68 }
setDefaultImpl(d: ITestServiceDefaultRef) -> ITestServiceDefaultRef where Self: Sized69 fn setDefaultImpl(d: ITestServiceDefaultRef) -> ITestServiceDefaultRef where Self: Sized {
70 std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d)
71 }
72 }
73 pub trait ITestServiceDefault: Send + Sync {
UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32>74 fn UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32> {
75 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
76 }
Deprecated(&self) -> binder::public_api::Result<()>77 fn Deprecated(&self) -> binder::public_api::Result<()> {
78 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
79 }
TestOneway(&self) -> binder::public_api::Result<()>80 fn TestOneway(&self) -> binder::public_api::Result<()> {
81 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
82 }
RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool>83 fn RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool> {
84 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
85 }
RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8>86 fn RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8> {
87 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
88 }
RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16>89 fn RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16> {
90 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
91 }
RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32>92 fn RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32> {
93 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
94 }
RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64>95 fn RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64> {
96 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
97 }
RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32>98 fn RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32> {
99 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
100 }
RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64>101 fn RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64> {
102 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
103 }
RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String>104 fn RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String> {
105 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
106 }
RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>107 fn RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> {
108 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
109 }
RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>110 fn RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> {
111 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
112 }
RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>113 fn RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> {
114 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
115 }
ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>>116 fn ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>> {
117 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
118 }
ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>>119 fn ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>> {
120 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
121 }
ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>>122 fn ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>> {
123 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
124 }
ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>>125 fn ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>> {
126 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
127 }
ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>>128 fn ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>> {
129 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
130 }
ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>>131 fn ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>> {
132 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
133 }
ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>>134 fn ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>> {
135 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
136 }
ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>137 fn ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
138 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
139 }
ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>140 fn ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>> {
141 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
142 }
ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>143 fn ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>> {
144 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
145 }
ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>146 fn ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>> {
147 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
148 }
GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>149 fn GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>> {
150 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
151 }
VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool>152 fn VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool> {
153 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
154 }
ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>155 fn ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
156 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
157 }
RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor>158 fn RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor> {
159 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
160 }
ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>>161 fn ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>> {
162 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
163 }
ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()>164 fn ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()> {
165 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
166 }
RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>>167 fn RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>> {
168 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
169 }
RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>>170 fn RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>> {
171 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
172 }
RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>>173 fn RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>> {
174 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
175 }
RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>>176 fn RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>> {
177 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
178 }
RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>>179 fn RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>> {
180 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
181 }
RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>>182 fn RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
183 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
184 }
RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>>185 fn RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>> {
186 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
187 }
TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()>188 fn TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()> {
189 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
190 }
TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()>191 fn TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()> {
192 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
193 }
RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String>194 fn RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String> {
195 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
196 }
RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>>197 fn RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>> {
198 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
199 }
ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>200 fn ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
201 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
202 }
ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>203 fn ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
204 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
205 }
ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>206 fn ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
207 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
208 }
GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>>209 fn GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>> {
210 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
211 }
FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()>212 fn FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()> {
213 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
214 }
GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>>215 fn GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>> {
216 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
217 }
GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>>218 fn GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>> {
219 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
220 }
GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>>221 fn GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>> {
222 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
223 }
getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType>224 fn getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType> {
225 Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())
226 }
227 }
228 pub mod transactions {
229 pub const UnimplementedMethod: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 0;
230 pub const Deprecated: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 1;
231 pub const TestOneway: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 2;
232 pub const RepeatBoolean: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 3;
233 pub const RepeatByte: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 4;
234 pub const RepeatChar: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 5;
235 pub const RepeatInt: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 6;
236 pub const RepeatLong: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 7;
237 pub const RepeatFloat: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 8;
238 pub const RepeatDouble: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 9;
239 pub const RepeatString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 10;
240 pub const RepeatByteEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 11;
241 pub const RepeatIntEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 12;
242 pub const RepeatLongEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 13;
243 pub const ReverseBoolean: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 14;
244 pub const ReverseByte: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 15;
245 pub const ReverseChar: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 16;
246 pub const ReverseInt: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 17;
247 pub const ReverseLong: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 18;
248 pub const ReverseFloat: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 19;
249 pub const ReverseDouble: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 20;
250 pub const ReverseString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 21;
251 pub const ReverseByteEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 22;
252 pub const ReverseIntEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 23;
253 pub const ReverseLongEnum: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 24;
254 pub const GetOtherTestService: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 25;
255 pub const VerifyName: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 26;
256 pub const ReverseStringList: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 27;
257 pub const RepeatParcelFileDescriptor: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 28;
258 pub const ReverseParcelFileDescriptorArray: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 29;
259 pub const ThrowServiceException: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 30;
260 pub const RepeatNullableIntArray: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 31;
261 pub const RepeatNullableByteEnumArray: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 32;
262 pub const RepeatNullableIntEnumArray: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 33;
263 pub const RepeatNullableLongEnumArray: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 34;
264 pub const RepeatNullableString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 35;
265 pub const RepeatNullableStringList: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 36;
266 pub const RepeatNullableParcelable: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 37;
267 pub const TakesAnIBinder: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 38;
268 pub const TakesANullableIBinder: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 39;
269 pub const RepeatUtf8CppString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 40;
270 pub const RepeatNullableUtf8CppString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 41;
271 pub const ReverseUtf8CppString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 42;
272 pub const ReverseNullableUtf8CppString: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 43;
273 pub const ReverseUtf8CppStringList: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 44;
274 pub const GetCallback: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 45;
275 pub const FillOutStructuredParcelable: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 46;
276 pub const GetOldNameInterface: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 47;
277 pub const GetNewNameInterface: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 48;
278 pub const GetCppJavaTests: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 49;
279 pub const getBackendType: binder::TransactionCode = binder::FIRST_CALL_TRANSACTION + 50;
280 }
281 pub type ITestServiceDefaultRef = Option<std::sync::Arc<dyn ITestServiceDefault>>;
282 use lazy_static::lazy_static;
283 lazy_static! {
284 static ref DEFAULT_IMPL: std::sync::Mutex<ITestServiceDefaultRef> = std::sync::Mutex::new(None);
285 }
286 pub const TEST_CONSTANT: i32 = 42;
287 pub const TEST_CONSTANT2: i32 = -42;
288 pub const TEST_CONSTANT3: i32 = 42;
289 pub const TEST_CONSTANT4: i32 = 4;
290 pub const TEST_CONSTANT5: i32 = -4;
291 pub const TEST_CONSTANT6: i32 = 0;
292 pub const TEST_CONSTANT7: i32 = 0;
293 pub const TEST_CONSTANT8: i32 = 0;
294 pub const TEST_CONSTANT9: i32 = 86;
295 pub const TEST_CONSTANT10: i32 = 165;
296 pub const TEST_CONSTANT11: i32 = 250;
297 pub const TEST_CONSTANT12: i32 = -1;
298 pub const BYTE_TEST_CONSTANT: i8 = 17;
299 pub const LONG_TEST_CONSTANT: i64 = 1099511627776;
300 pub const STRING_TEST_CONSTANT: &str = "foo";
301 pub const STRING_TEST_CONSTANT2: &str = "bar";
302 pub const STRING_TEST_CONSTANT_UTF8: &str = "baz";
303 pub const A1: i32 = 1;
304 pub const A2: i32 = 1;
305 pub const A3: i32 = 1;
306 pub const A4: i32 = 1;
307 pub const A5: i32 = 1;
308 pub const A6: i32 = 1;
309 pub const A7: i32 = 1;
310 pub const A8: i32 = 1;
311 pub const A9: i32 = 1;
312 pub const A10: i32 = 1;
313 pub const A11: i32 = 1;
314 pub const A12: i32 = 1;
315 pub const A13: i32 = 1;
316 pub const A14: i32 = 1;
317 pub const A15: i32 = 1;
318 pub const A16: i32 = 1;
319 pub const A17: i32 = 1;
320 pub const A18: i32 = 1;
321 pub const A19: i32 = 1;
322 pub const A20: i32 = 1;
323 pub const A21: i32 = 1;
324 pub const A22: i32 = 1;
325 pub const A23: i32 = 1;
326 pub const A24: i32 = 1;
327 pub const A25: i32 = 1;
328 pub const A26: i32 = 1;
329 pub const A27: i32 = 1;
330 pub const A28: i32 = 1;
331 pub const A29: i32 = 1;
332 pub const A30: i32 = 1;
333 pub const A31: i32 = 1;
334 pub const A32: i32 = 1;
335 pub const A33: i32 = 1;
336 pub const A34: i32 = 1;
337 pub const A35: i32 = 1;
338 pub const A36: i32 = 1;
339 pub const A37: i32 = 1;
340 pub const A38: i32 = 1;
341 pub const A39: i32 = 1;
342 pub const A40: i32 = 1;
343 pub const A41: i32 = 1;
344 pub const A42: i32 = 1;
345 pub const A43: i32 = 1;
346 pub const A44: i32 = 1;
347 pub const A45: i32 = 1;
348 pub const A46: i32 = 1;
349 pub const A47: i32 = 1;
350 pub const A48: i32 = 1;
351 pub const A49: i32 = 1;
352 pub const A50: i32 = 1;
353 pub const A51: i32 = 1;
354 pub const A52: i32 = 1;
355 pub const A53: i32 = 1;
356 pub const A54: i32 = 1;
357 pub const A55: i32 = 1;
358 pub const A56: i32 = 1;
359 pub const A57: i32 = 1;
360 pub(crate) mod mangled { pub use super::ITestService as _7_android_4_aidl_5_tests_12_ITestService; }
361 impl ITestService for BpTestService {
UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32>362 fn UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32> {
363 let _aidl_reply = self.binder.transact(transactions::UnimplementedMethod, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
364 _aidl_data.mark_sensitive();
365 _aidl_data.write(&_arg_arg)?;
366 Ok(())
367 });
368 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
369 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
370 return _aidl_default_impl.UnimplementedMethod(_arg_arg);
371 }
372 }
373 let _aidl_reply = _aidl_reply?;
374 let _aidl_status: binder::Status = _aidl_reply.read()?;
375 if !_aidl_status.is_ok() { return Err(_aidl_status); }
376 let _aidl_return: i32 = _aidl_reply.read()?;
377 Ok(_aidl_return)
378 }
Deprecated(&self) -> binder::public_api::Result<()>379 fn Deprecated(&self) -> binder::public_api::Result<()> {
380 let _aidl_reply = self.binder.transact(transactions::Deprecated, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
381 _aidl_data.mark_sensitive();
382 Ok(())
383 });
384 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
385 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
386 return _aidl_default_impl.Deprecated();
387 }
388 }
389 let _aidl_reply = _aidl_reply?;
390 let _aidl_status: binder::Status = _aidl_reply.read()?;
391 if !_aidl_status.is_ok() { return Err(_aidl_status); }
392 Ok(())
393 }
TestOneway(&self) -> binder::public_api::Result<()>394 fn TestOneway(&self) -> binder::public_api::Result<()> {
395 let _aidl_reply = self.binder.transact(transactions::TestOneway, binder::FLAG_ONEWAY | binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
396 _aidl_data.mark_sensitive();
397 Ok(())
398 });
399 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
400 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
401 return _aidl_default_impl.TestOneway();
402 }
403 }
404 let _aidl_reply = _aidl_reply?;
405 Ok(())
406 }
RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool>407 fn RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool> {
408 let _aidl_reply = self.binder.transact(transactions::RepeatBoolean, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
409 _aidl_data.mark_sensitive();
410 _aidl_data.write(&_arg_token)?;
411 Ok(())
412 });
413 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
414 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
415 return _aidl_default_impl.RepeatBoolean(_arg_token);
416 }
417 }
418 let _aidl_reply = _aidl_reply?;
419 let _aidl_status: binder::Status = _aidl_reply.read()?;
420 if !_aidl_status.is_ok() { return Err(_aidl_status); }
421 let _aidl_return: bool = _aidl_reply.read()?;
422 Ok(_aidl_return)
423 }
RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8>424 fn RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8> {
425 let _aidl_reply = self.binder.transact(transactions::RepeatByte, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
426 _aidl_data.mark_sensitive();
427 _aidl_data.write(&_arg_token)?;
428 Ok(())
429 });
430 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
431 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
432 return _aidl_default_impl.RepeatByte(_arg_token);
433 }
434 }
435 let _aidl_reply = _aidl_reply?;
436 let _aidl_status: binder::Status = _aidl_reply.read()?;
437 if !_aidl_status.is_ok() { return Err(_aidl_status); }
438 let _aidl_return: i8 = _aidl_reply.read()?;
439 Ok(_aidl_return)
440 }
RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16>441 fn RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16> {
442 let _aidl_reply = self.binder.transact(transactions::RepeatChar, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
443 _aidl_data.mark_sensitive();
444 _aidl_data.write(&_arg_token)?;
445 Ok(())
446 });
447 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
448 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
449 return _aidl_default_impl.RepeatChar(_arg_token);
450 }
451 }
452 let _aidl_reply = _aidl_reply?;
453 let _aidl_status: binder::Status = _aidl_reply.read()?;
454 if !_aidl_status.is_ok() { return Err(_aidl_status); }
455 let _aidl_return: u16 = _aidl_reply.read()?;
456 Ok(_aidl_return)
457 }
RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32>458 fn RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32> {
459 let _aidl_reply = self.binder.transact(transactions::RepeatInt, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
460 _aidl_data.mark_sensitive();
461 _aidl_data.write(&_arg_token)?;
462 Ok(())
463 });
464 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
465 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
466 return _aidl_default_impl.RepeatInt(_arg_token);
467 }
468 }
469 let _aidl_reply = _aidl_reply?;
470 let _aidl_status: binder::Status = _aidl_reply.read()?;
471 if !_aidl_status.is_ok() { return Err(_aidl_status); }
472 let _aidl_return: i32 = _aidl_reply.read()?;
473 Ok(_aidl_return)
474 }
RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64>475 fn RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64> {
476 let _aidl_reply = self.binder.transact(transactions::RepeatLong, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
477 _aidl_data.mark_sensitive();
478 _aidl_data.write(&_arg_token)?;
479 Ok(())
480 });
481 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
482 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
483 return _aidl_default_impl.RepeatLong(_arg_token);
484 }
485 }
486 let _aidl_reply = _aidl_reply?;
487 let _aidl_status: binder::Status = _aidl_reply.read()?;
488 if !_aidl_status.is_ok() { return Err(_aidl_status); }
489 let _aidl_return: i64 = _aidl_reply.read()?;
490 Ok(_aidl_return)
491 }
RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32>492 fn RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32> {
493 let _aidl_reply = self.binder.transact(transactions::RepeatFloat, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
494 _aidl_data.mark_sensitive();
495 _aidl_data.write(&_arg_token)?;
496 Ok(())
497 });
498 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
499 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
500 return _aidl_default_impl.RepeatFloat(_arg_token);
501 }
502 }
503 let _aidl_reply = _aidl_reply?;
504 let _aidl_status: binder::Status = _aidl_reply.read()?;
505 if !_aidl_status.is_ok() { return Err(_aidl_status); }
506 let _aidl_return: f32 = _aidl_reply.read()?;
507 Ok(_aidl_return)
508 }
RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64>509 fn RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64> {
510 let _aidl_reply = self.binder.transact(transactions::RepeatDouble, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
511 _aidl_data.mark_sensitive();
512 _aidl_data.write(&_arg_token)?;
513 Ok(())
514 });
515 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
516 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
517 return _aidl_default_impl.RepeatDouble(_arg_token);
518 }
519 }
520 let _aidl_reply = _aidl_reply?;
521 let _aidl_status: binder::Status = _aidl_reply.read()?;
522 if !_aidl_status.is_ok() { return Err(_aidl_status); }
523 let _aidl_return: f64 = _aidl_reply.read()?;
524 Ok(_aidl_return)
525 }
RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String>526 fn RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String> {
527 let _aidl_reply = self.binder.transact(transactions::RepeatString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
528 _aidl_data.mark_sensitive();
529 _aidl_data.write(_arg_token)?;
530 Ok(())
531 });
532 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
533 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
534 return _aidl_default_impl.RepeatString(_arg_token);
535 }
536 }
537 let _aidl_reply = _aidl_reply?;
538 let _aidl_status: binder::Status = _aidl_reply.read()?;
539 if !_aidl_status.is_ok() { return Err(_aidl_status); }
540 let _aidl_return: String = _aidl_reply.read()?;
541 Ok(_aidl_return)
542 }
RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>543 fn RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> {
544 let _aidl_reply = self.binder.transact(transactions::RepeatByteEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
545 _aidl_data.mark_sensitive();
546 _aidl_data.write(&_arg_token)?;
547 Ok(())
548 });
549 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
550 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
551 return _aidl_default_impl.RepeatByteEnum(_arg_token);
552 }
553 }
554 let _aidl_reply = _aidl_reply?;
555 let _aidl_status: binder::Status = _aidl_reply.read()?;
556 if !_aidl_status.is_ok() { return Err(_aidl_status); }
557 let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_reply.read()?;
558 Ok(_aidl_return)
559 }
RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>560 fn RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> {
561 let _aidl_reply = self.binder.transact(transactions::RepeatIntEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
562 _aidl_data.mark_sensitive();
563 _aidl_data.write(&_arg_token)?;
564 Ok(())
565 });
566 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
567 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
568 return _aidl_default_impl.RepeatIntEnum(_arg_token);
569 }
570 }
571 let _aidl_reply = _aidl_reply?;
572 let _aidl_status: binder::Status = _aidl_reply.read()?;
573 if !_aidl_status.is_ok() { return Err(_aidl_status); }
574 let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_reply.read()?;
575 Ok(_aidl_return)
576 }
RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>577 fn RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> {
578 let _aidl_reply = self.binder.transact(transactions::RepeatLongEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
579 _aidl_data.mark_sensitive();
580 _aidl_data.write(&_arg_token)?;
581 Ok(())
582 });
583 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
584 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
585 return _aidl_default_impl.RepeatLongEnum(_arg_token);
586 }
587 }
588 let _aidl_reply = _aidl_reply?;
589 let _aidl_status: binder::Status = _aidl_reply.read()?;
590 if !_aidl_status.is_ok() { return Err(_aidl_status); }
591 let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_reply.read()?;
592 Ok(_aidl_return)
593 }
ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>>594 fn ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>> {
595 let _aidl_reply = self.binder.transact(transactions::ReverseBoolean, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
596 _aidl_data.mark_sensitive();
597 _aidl_data.write(_arg_input)?;
598 _aidl_data.write_slice_size(Some(_arg_repeated))?;
599 Ok(())
600 });
601 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
602 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
603 return _aidl_default_impl.ReverseBoolean(_arg_input, _arg_repeated);
604 }
605 }
606 let _aidl_reply = _aidl_reply?;
607 let _aidl_status: binder::Status = _aidl_reply.read()?;
608 if !_aidl_status.is_ok() { return Err(_aidl_status); }
609 let _aidl_return: Vec<bool> = _aidl_reply.read()?;
610 *_arg_repeated = _aidl_reply.read()?;
611 Ok(_aidl_return)
612 }
ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>>613 fn ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>> {
614 let _aidl_reply = self.binder.transact(transactions::ReverseByte, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
615 _aidl_data.mark_sensitive();
616 _aidl_data.write(_arg_input)?;
617 _aidl_data.write_slice_size(Some(_arg_repeated))?;
618 Ok(())
619 });
620 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
621 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
622 return _aidl_default_impl.ReverseByte(_arg_input, _arg_repeated);
623 }
624 }
625 let _aidl_reply = _aidl_reply?;
626 let _aidl_status: binder::Status = _aidl_reply.read()?;
627 if !_aidl_status.is_ok() { return Err(_aidl_status); }
628 let _aidl_return: Vec<u8> = _aidl_reply.read()?;
629 *_arg_repeated = _aidl_reply.read()?;
630 Ok(_aidl_return)
631 }
ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>>632 fn ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>> {
633 let _aidl_reply = self.binder.transact(transactions::ReverseChar, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
634 _aidl_data.mark_sensitive();
635 _aidl_data.write(_arg_input)?;
636 _aidl_data.write_slice_size(Some(_arg_repeated))?;
637 Ok(())
638 });
639 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
640 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
641 return _aidl_default_impl.ReverseChar(_arg_input, _arg_repeated);
642 }
643 }
644 let _aidl_reply = _aidl_reply?;
645 let _aidl_status: binder::Status = _aidl_reply.read()?;
646 if !_aidl_status.is_ok() { return Err(_aidl_status); }
647 let _aidl_return: Vec<u16> = _aidl_reply.read()?;
648 *_arg_repeated = _aidl_reply.read()?;
649 Ok(_aidl_return)
650 }
ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>>651 fn ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>> {
652 let _aidl_reply = self.binder.transact(transactions::ReverseInt, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
653 _aidl_data.mark_sensitive();
654 _aidl_data.write(_arg_input)?;
655 _aidl_data.write_slice_size(Some(_arg_repeated))?;
656 Ok(())
657 });
658 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
659 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
660 return _aidl_default_impl.ReverseInt(_arg_input, _arg_repeated);
661 }
662 }
663 let _aidl_reply = _aidl_reply?;
664 let _aidl_status: binder::Status = _aidl_reply.read()?;
665 if !_aidl_status.is_ok() { return Err(_aidl_status); }
666 let _aidl_return: Vec<i32> = _aidl_reply.read()?;
667 *_arg_repeated = _aidl_reply.read()?;
668 Ok(_aidl_return)
669 }
ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>>670 fn ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>> {
671 let _aidl_reply = self.binder.transact(transactions::ReverseLong, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
672 _aidl_data.mark_sensitive();
673 _aidl_data.write(_arg_input)?;
674 _aidl_data.write_slice_size(Some(_arg_repeated))?;
675 Ok(())
676 });
677 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
678 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
679 return _aidl_default_impl.ReverseLong(_arg_input, _arg_repeated);
680 }
681 }
682 let _aidl_reply = _aidl_reply?;
683 let _aidl_status: binder::Status = _aidl_reply.read()?;
684 if !_aidl_status.is_ok() { return Err(_aidl_status); }
685 let _aidl_return: Vec<i64> = _aidl_reply.read()?;
686 *_arg_repeated = _aidl_reply.read()?;
687 Ok(_aidl_return)
688 }
ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>>689 fn ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>> {
690 let _aidl_reply = self.binder.transact(transactions::ReverseFloat, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
691 _aidl_data.mark_sensitive();
692 _aidl_data.write(_arg_input)?;
693 _aidl_data.write_slice_size(Some(_arg_repeated))?;
694 Ok(())
695 });
696 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
697 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
698 return _aidl_default_impl.ReverseFloat(_arg_input, _arg_repeated);
699 }
700 }
701 let _aidl_reply = _aidl_reply?;
702 let _aidl_status: binder::Status = _aidl_reply.read()?;
703 if !_aidl_status.is_ok() { return Err(_aidl_status); }
704 let _aidl_return: Vec<f32> = _aidl_reply.read()?;
705 *_arg_repeated = _aidl_reply.read()?;
706 Ok(_aidl_return)
707 }
ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>>708 fn ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>> {
709 let _aidl_reply = self.binder.transact(transactions::ReverseDouble, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
710 _aidl_data.mark_sensitive();
711 _aidl_data.write(_arg_input)?;
712 _aidl_data.write_slice_size(Some(_arg_repeated))?;
713 Ok(())
714 });
715 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
716 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
717 return _aidl_default_impl.ReverseDouble(_arg_input, _arg_repeated);
718 }
719 }
720 let _aidl_reply = _aidl_reply?;
721 let _aidl_status: binder::Status = _aidl_reply.read()?;
722 if !_aidl_status.is_ok() { return Err(_aidl_status); }
723 let _aidl_return: Vec<f64> = _aidl_reply.read()?;
724 *_arg_repeated = _aidl_reply.read()?;
725 Ok(_aidl_return)
726 }
ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>727 fn ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
728 let _aidl_reply = self.binder.transact(transactions::ReverseString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
729 _aidl_data.mark_sensitive();
730 _aidl_data.write(_arg_input)?;
731 _aidl_data.write_slice_size(Some(_arg_repeated))?;
732 Ok(())
733 });
734 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
735 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
736 return _aidl_default_impl.ReverseString(_arg_input, _arg_repeated);
737 }
738 }
739 let _aidl_reply = _aidl_reply?;
740 let _aidl_status: binder::Status = _aidl_reply.read()?;
741 if !_aidl_status.is_ok() { return Err(_aidl_status); }
742 let _aidl_return: Vec<String> = _aidl_reply.read()?;
743 *_arg_repeated = _aidl_reply.read()?;
744 Ok(_aidl_return)
745 }
ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>746 fn ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>> {
747 let _aidl_reply = self.binder.transact(transactions::ReverseByteEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
748 _aidl_data.mark_sensitive();
749 _aidl_data.write(_arg_input)?;
750 _aidl_data.write_slice_size(Some(_arg_repeated))?;
751 Ok(())
752 });
753 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
754 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
755 return _aidl_default_impl.ReverseByteEnum(_arg_input, _arg_repeated);
756 }
757 }
758 let _aidl_reply = _aidl_reply?;
759 let _aidl_status: binder::Status = _aidl_reply.read()?;
760 if !_aidl_status.is_ok() { return Err(_aidl_status); }
761 let _aidl_return: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> = _aidl_reply.read()?;
762 *_arg_repeated = _aidl_reply.read()?;
763 Ok(_aidl_return)
764 }
ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>765 fn ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>> {
766 let _aidl_reply = self.binder.transact(transactions::ReverseIntEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
767 _aidl_data.mark_sensitive();
768 _aidl_data.write(_arg_input)?;
769 _aidl_data.write_slice_size(Some(_arg_repeated))?;
770 Ok(())
771 });
772 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
773 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
774 return _aidl_default_impl.ReverseIntEnum(_arg_input, _arg_repeated);
775 }
776 }
777 let _aidl_reply = _aidl_reply?;
778 let _aidl_status: binder::Status = _aidl_reply.read()?;
779 if !_aidl_status.is_ok() { return Err(_aidl_status); }
780 let _aidl_return: Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> = _aidl_reply.read()?;
781 *_arg_repeated = _aidl_reply.read()?;
782 Ok(_aidl_return)
783 }
ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>784 fn ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>> {
785 let _aidl_reply = self.binder.transact(transactions::ReverseLongEnum, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
786 _aidl_data.mark_sensitive();
787 _aidl_data.write(_arg_input)?;
788 _aidl_data.write_slice_size(Some(_arg_repeated))?;
789 Ok(())
790 });
791 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
792 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
793 return _aidl_default_impl.ReverseLongEnum(_arg_input, _arg_repeated);
794 }
795 }
796 let _aidl_reply = _aidl_reply?;
797 let _aidl_status: binder::Status = _aidl_reply.read()?;
798 if !_aidl_status.is_ok() { return Err(_aidl_status); }
799 let _aidl_return: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> = _aidl_reply.read()?;
800 *_arg_repeated = _aidl_reply.read()?;
801 Ok(_aidl_return)
802 }
GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>803 fn GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>> {
804 let _aidl_reply = self.binder.transact(transactions::GetOtherTestService, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
805 _aidl_data.mark_sensitive();
806 _aidl_data.write(_arg_name)?;
807 Ok(())
808 });
809 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
810 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
811 return _aidl_default_impl.GetOtherTestService(_arg_name);
812 }
813 }
814 let _aidl_reply = _aidl_reply?;
815 let _aidl_status: binder::Status = _aidl_reply.read()?;
816 if !_aidl_status.is_ok() { return Err(_aidl_status); }
817 let _aidl_return: binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback> = _aidl_reply.read()?;
818 Ok(_aidl_return)
819 }
VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool>820 fn VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool> {
821 let _aidl_reply = self.binder.transact(transactions::VerifyName, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
822 _aidl_data.mark_sensitive();
823 _aidl_data.write(_arg_service)?;
824 _aidl_data.write(_arg_name)?;
825 Ok(())
826 });
827 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
828 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
829 return _aidl_default_impl.VerifyName(_arg_service, _arg_name);
830 }
831 }
832 let _aidl_reply = _aidl_reply?;
833 let _aidl_status: binder::Status = _aidl_reply.read()?;
834 if !_aidl_status.is_ok() { return Err(_aidl_status); }
835 let _aidl_return: bool = _aidl_reply.read()?;
836 Ok(_aidl_return)
837 }
ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>838 fn ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
839 let _aidl_reply = self.binder.transact(transactions::ReverseStringList, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
840 _aidl_data.mark_sensitive();
841 _aidl_data.write(_arg_input)?;
842 Ok(())
843 });
844 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
845 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
846 return _aidl_default_impl.ReverseStringList(_arg_input, _arg_repeated);
847 }
848 }
849 let _aidl_reply = _aidl_reply?;
850 let _aidl_status: binder::Status = _aidl_reply.read()?;
851 if !_aidl_status.is_ok() { return Err(_aidl_status); }
852 let _aidl_return: Vec<String> = _aidl_reply.read()?;
853 *_arg_repeated = _aidl_reply.read()?;
854 Ok(_aidl_return)
855 }
RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor>856 fn RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor> {
857 let _aidl_reply = self.binder.transact(transactions::RepeatParcelFileDescriptor, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
858 _aidl_data.mark_sensitive();
859 _aidl_data.write(_arg_read)?;
860 Ok(())
861 });
862 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
863 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
864 return _aidl_default_impl.RepeatParcelFileDescriptor(_arg_read);
865 }
866 }
867 let _aidl_reply = _aidl_reply?;
868 let _aidl_status: binder::Status = _aidl_reply.read()?;
869 if !_aidl_status.is_ok() { return Err(_aidl_status); }
870 let _aidl_return: binder::parcel::ParcelFileDescriptor = _aidl_reply.read()?;
871 Ok(_aidl_return)
872 }
ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>>873 fn ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>> {
874 let _aidl_reply = self.binder.transact(transactions::ReverseParcelFileDescriptorArray, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
875 _aidl_data.mark_sensitive();
876 _aidl_data.write(_arg_input)?;
877 _aidl_data.write_slice_size(Some(_arg_repeated))?;
878 Ok(())
879 });
880 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
881 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
882 return _aidl_default_impl.ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated);
883 }
884 }
885 let _aidl_reply = _aidl_reply?;
886 let _aidl_status: binder::Status = _aidl_reply.read()?;
887 if !_aidl_status.is_ok() { return Err(_aidl_status); }
888 let _aidl_return: Vec<binder::parcel::ParcelFileDescriptor> = _aidl_reply.read()?;
889 *_arg_repeated = _aidl_reply.read()?;
890 Ok(_aidl_return)
891 }
ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()>892 fn ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()> {
893 let _aidl_reply = self.binder.transact(transactions::ThrowServiceException, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
894 _aidl_data.mark_sensitive();
895 _aidl_data.write(&_arg_code)?;
896 Ok(())
897 });
898 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
899 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
900 return _aidl_default_impl.ThrowServiceException(_arg_code);
901 }
902 }
903 let _aidl_reply = _aidl_reply?;
904 let _aidl_status: binder::Status = _aidl_reply.read()?;
905 if !_aidl_status.is_ok() { return Err(_aidl_status); }
906 Ok(())
907 }
RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>>908 fn RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>> {
909 let _aidl_reply = self.binder.transact(transactions::RepeatNullableIntArray, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
910 _aidl_data.mark_sensitive();
911 _aidl_data.write(&_arg_input)?;
912 Ok(())
913 });
914 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
915 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
916 return _aidl_default_impl.RepeatNullableIntArray(_arg_input);
917 }
918 }
919 let _aidl_reply = _aidl_reply?;
920 let _aidl_status: binder::Status = _aidl_reply.read()?;
921 if !_aidl_status.is_ok() { return Err(_aidl_status); }
922 let _aidl_return: Option<Vec<i32>> = _aidl_reply.read()?;
923 Ok(_aidl_return)
924 }
RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>>925 fn RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>> {
926 let _aidl_reply = self.binder.transact(transactions::RepeatNullableByteEnumArray, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
927 _aidl_data.mark_sensitive();
928 _aidl_data.write(&_arg_input)?;
929 Ok(())
930 });
931 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
932 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
933 return _aidl_default_impl.RepeatNullableByteEnumArray(_arg_input);
934 }
935 }
936 let _aidl_reply = _aidl_reply?;
937 let _aidl_status: binder::Status = _aidl_reply.read()?;
938 if !_aidl_status.is_ok() { return Err(_aidl_status); }
939 let _aidl_return: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>> = _aidl_reply.read()?;
940 Ok(_aidl_return)
941 }
RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>>942 fn RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>> {
943 let _aidl_reply = self.binder.transact(transactions::RepeatNullableIntEnumArray, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
944 _aidl_data.mark_sensitive();
945 _aidl_data.write(&_arg_input)?;
946 Ok(())
947 });
948 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
949 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
950 return _aidl_default_impl.RepeatNullableIntEnumArray(_arg_input);
951 }
952 }
953 let _aidl_reply = _aidl_reply?;
954 let _aidl_status: binder::Status = _aidl_reply.read()?;
955 if !_aidl_status.is_ok() { return Err(_aidl_status); }
956 let _aidl_return: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>> = _aidl_reply.read()?;
957 Ok(_aidl_return)
958 }
RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>>959 fn RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>> {
960 let _aidl_reply = self.binder.transact(transactions::RepeatNullableLongEnumArray, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
961 _aidl_data.mark_sensitive();
962 _aidl_data.write(&_arg_input)?;
963 Ok(())
964 });
965 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
966 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
967 return _aidl_default_impl.RepeatNullableLongEnumArray(_arg_input);
968 }
969 }
970 let _aidl_reply = _aidl_reply?;
971 let _aidl_status: binder::Status = _aidl_reply.read()?;
972 if !_aidl_status.is_ok() { return Err(_aidl_status); }
973 let _aidl_return: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>> = _aidl_reply.read()?;
974 Ok(_aidl_return)
975 }
RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>>976 fn RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>> {
977 let _aidl_reply = self.binder.transact(transactions::RepeatNullableString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
978 _aidl_data.mark_sensitive();
979 _aidl_data.write(&_arg_input)?;
980 Ok(())
981 });
982 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
983 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
984 return _aidl_default_impl.RepeatNullableString(_arg_input);
985 }
986 }
987 let _aidl_reply = _aidl_reply?;
988 let _aidl_status: binder::Status = _aidl_reply.read()?;
989 if !_aidl_status.is_ok() { return Err(_aidl_status); }
990 let _aidl_return: Option<String> = _aidl_reply.read()?;
991 Ok(_aidl_return)
992 }
RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>>993 fn RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
994 let _aidl_reply = self.binder.transact(transactions::RepeatNullableStringList, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
995 _aidl_data.mark_sensitive();
996 _aidl_data.write(&_arg_input)?;
997 Ok(())
998 });
999 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1000 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1001 return _aidl_default_impl.RepeatNullableStringList(_arg_input);
1002 }
1003 }
1004 let _aidl_reply = _aidl_reply?;
1005 let _aidl_status: binder::Status = _aidl_reply.read()?;
1006 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1007 let _aidl_return: Option<Vec<Option<String>>> = _aidl_reply.read()?;
1008 Ok(_aidl_return)
1009 }
RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>>1010 fn RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>> {
1011 let _aidl_reply = self.binder.transact(transactions::RepeatNullableParcelable, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1012 _aidl_data.mark_sensitive();
1013 _aidl_data.write(&_arg_input)?;
1014 Ok(())
1015 });
1016 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1017 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1018 return _aidl_default_impl.RepeatNullableParcelable(_arg_input);
1019 }
1020 }
1021 let _aidl_reply = _aidl_reply?;
1022 let _aidl_status: binder::Status = _aidl_reply.read()?;
1023 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1024 let _aidl_return: Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable> = _aidl_reply.read()?;
1025 Ok(_aidl_return)
1026 }
TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()>1027 fn TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()> {
1028 let _aidl_reply = self.binder.transact(transactions::TakesAnIBinder, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1029 _aidl_data.mark_sensitive();
1030 _aidl_data.write(_arg_input)?;
1031 Ok(())
1032 });
1033 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1034 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1035 return _aidl_default_impl.TakesAnIBinder(_arg_input);
1036 }
1037 }
1038 let _aidl_reply = _aidl_reply?;
1039 let _aidl_status: binder::Status = _aidl_reply.read()?;
1040 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1041 Ok(())
1042 }
TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()>1043 fn TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()> {
1044 let _aidl_reply = self.binder.transact(transactions::TakesANullableIBinder, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1045 _aidl_data.mark_sensitive();
1046 _aidl_data.write(&_arg_input)?;
1047 Ok(())
1048 });
1049 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1050 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1051 return _aidl_default_impl.TakesANullableIBinder(_arg_input);
1052 }
1053 }
1054 let _aidl_reply = _aidl_reply?;
1055 let _aidl_status: binder::Status = _aidl_reply.read()?;
1056 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1057 Ok(())
1058 }
RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String>1059 fn RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String> {
1060 let _aidl_reply = self.binder.transact(transactions::RepeatUtf8CppString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1061 _aidl_data.mark_sensitive();
1062 _aidl_data.write(_arg_token)?;
1063 Ok(())
1064 });
1065 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1066 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1067 return _aidl_default_impl.RepeatUtf8CppString(_arg_token);
1068 }
1069 }
1070 let _aidl_reply = _aidl_reply?;
1071 let _aidl_status: binder::Status = _aidl_reply.read()?;
1072 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1073 let _aidl_return: String = _aidl_reply.read()?;
1074 Ok(_aidl_return)
1075 }
RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>>1076 fn RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>> {
1077 let _aidl_reply = self.binder.transact(transactions::RepeatNullableUtf8CppString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1078 _aidl_data.mark_sensitive();
1079 _aidl_data.write(&_arg_token)?;
1080 Ok(())
1081 });
1082 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1083 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1084 return _aidl_default_impl.RepeatNullableUtf8CppString(_arg_token);
1085 }
1086 }
1087 let _aidl_reply = _aidl_reply?;
1088 let _aidl_status: binder::Status = _aidl_reply.read()?;
1089 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1090 let _aidl_return: Option<String> = _aidl_reply.read()?;
1091 Ok(_aidl_return)
1092 }
ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>1093 fn ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> {
1094 let _aidl_reply = self.binder.transact(transactions::ReverseUtf8CppString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1095 _aidl_data.mark_sensitive();
1096 _aidl_data.write(_arg_input)?;
1097 _aidl_data.write_slice_size(Some(_arg_repeated))?;
1098 Ok(())
1099 });
1100 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1101 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1102 return _aidl_default_impl.ReverseUtf8CppString(_arg_input, _arg_repeated);
1103 }
1104 }
1105 let _aidl_reply = _aidl_reply?;
1106 let _aidl_status: binder::Status = _aidl_reply.read()?;
1107 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1108 let _aidl_return: Vec<String> = _aidl_reply.read()?;
1109 *_arg_repeated = _aidl_reply.read()?;
1110 Ok(_aidl_return)
1111 }
ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>1112 fn ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
1113 let _aidl_reply = self.binder.transact(transactions::ReverseNullableUtf8CppString, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1114 _aidl_data.mark_sensitive();
1115 _aidl_data.write(&_arg_input)?;
1116 _aidl_data.write_slice_size(_arg_repeated.as_deref())?;
1117 Ok(())
1118 });
1119 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1120 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1121 return _aidl_default_impl.ReverseNullableUtf8CppString(_arg_input, _arg_repeated);
1122 }
1123 }
1124 let _aidl_reply = _aidl_reply?;
1125 let _aidl_status: binder::Status = _aidl_reply.read()?;
1126 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1127 let _aidl_return: Option<Vec<Option<String>>> = _aidl_reply.read()?;
1128 *_arg_repeated = _aidl_reply.read()?;
1129 Ok(_aidl_return)
1130 }
ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>1131 fn ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> {
1132 let _aidl_reply = self.binder.transact(transactions::ReverseUtf8CppStringList, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1133 _aidl_data.mark_sensitive();
1134 _aidl_data.write(&_arg_input)?;
1135 Ok(())
1136 });
1137 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1138 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1139 return _aidl_default_impl.ReverseUtf8CppStringList(_arg_input, _arg_repeated);
1140 }
1141 }
1142 let _aidl_reply = _aidl_reply?;
1143 let _aidl_status: binder::Status = _aidl_reply.read()?;
1144 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1145 let _aidl_return: Option<Vec<Option<String>>> = _aidl_reply.read()?;
1146 *_arg_repeated = _aidl_reply.read()?;
1147 Ok(_aidl_return)
1148 }
GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>>1149 fn GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>> {
1150 let _aidl_reply = self.binder.transact(transactions::GetCallback, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1151 _aidl_data.mark_sensitive();
1152 _aidl_data.write(&_arg_return_null)?;
1153 Ok(())
1154 });
1155 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1156 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1157 return _aidl_default_impl.GetCallback(_arg_return_null);
1158 }
1159 }
1160 let _aidl_reply = _aidl_reply?;
1161 let _aidl_status: binder::Status = _aidl_reply.read()?;
1162 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1163 let _aidl_return: Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>> = _aidl_reply.read()?;
1164 Ok(_aidl_return)
1165 }
FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()>1166 fn FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()> {
1167 let _aidl_reply = self.binder.transact(transactions::FillOutStructuredParcelable, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1168 _aidl_data.mark_sensitive();
1169 _aidl_data.write(_arg_parcel)?;
1170 Ok(())
1171 });
1172 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1173 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1174 return _aidl_default_impl.FillOutStructuredParcelable(_arg_parcel);
1175 }
1176 }
1177 let _aidl_reply = _aidl_reply?;
1178 let _aidl_status: binder::Status = _aidl_reply.read()?;
1179 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1180 *_arg_parcel = _aidl_reply.read()?;
1181 Ok(())
1182 }
GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>>1183 fn GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>> {
1184 let _aidl_reply = self.binder.transact(transactions::GetOldNameInterface, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1185 _aidl_data.mark_sensitive();
1186 Ok(())
1187 });
1188 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1189 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1190 return _aidl_default_impl.GetOldNameInterface();
1191 }
1192 }
1193 let _aidl_reply = _aidl_reply?;
1194 let _aidl_status: binder::Status = _aidl_reply.read()?;
1195 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1196 let _aidl_return: binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName> = _aidl_reply.read()?;
1197 Ok(_aidl_return)
1198 }
GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>>1199 fn GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>> {
1200 let _aidl_reply = self.binder.transact(transactions::GetNewNameInterface, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1201 _aidl_data.mark_sensitive();
1202 Ok(())
1203 });
1204 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1205 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1206 return _aidl_default_impl.GetNewNameInterface();
1207 }
1208 }
1209 let _aidl_reply = _aidl_reply?;
1210 let _aidl_status: binder::Status = _aidl_reply.read()?;
1211 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1212 let _aidl_return: binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName> = _aidl_reply.read()?;
1213 Ok(_aidl_return)
1214 }
GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>>1215 fn GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>> {
1216 let _aidl_reply = self.binder.transact(transactions::GetCppJavaTests, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1217 _aidl_data.mark_sensitive();
1218 Ok(())
1219 });
1220 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1221 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1222 return _aidl_default_impl.GetCppJavaTests();
1223 }
1224 }
1225 let _aidl_reply = _aidl_reply?;
1226 let _aidl_status: binder::Status = _aidl_reply.read()?;
1227 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1228 let _aidl_return: Option<binder::SpIBinder> = _aidl_reply.read()?;
1229 Ok(_aidl_return)
1230 }
getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType>1231 fn getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType> {
1232 let _aidl_reply = self.binder.transact(transactions::getBackendType, binder::FLAG_CLEAR_BUF | binder::FLAG_PRIVATE_LOCAL, |_aidl_data| {
1233 _aidl_data.mark_sensitive();
1234 Ok(())
1235 });
1236 if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {
1237 if let Some(_aidl_default_impl) = <Self as ITestService>::getDefaultImpl() {
1238 return _aidl_default_impl.getBackendType();
1239 }
1240 }
1241 let _aidl_reply = _aidl_reply?;
1242 let _aidl_status: binder::Status = _aidl_reply.read()?;
1243 if !_aidl_status.is_ok() { return Err(_aidl_status); }
1244 let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_11_BackendType = _aidl_reply.read()?;
1245 Ok(_aidl_return)
1246 }
1247 }
1248 impl ITestService for binder::Binder<BnTestService> {
UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32>1249 fn UnimplementedMethod(&self, _arg_arg: i32) -> binder::public_api::Result<i32> { self.0.UnimplementedMethod(_arg_arg) }
Deprecated(&self) -> binder::public_api::Result<()>1250 fn Deprecated(&self) -> binder::public_api::Result<()> { self.0.Deprecated() }
TestOneway(&self) -> binder::public_api::Result<()>1251 fn TestOneway(&self) -> binder::public_api::Result<()> { self.0.TestOneway() }
RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool>1252 fn RepeatBoolean(&self, _arg_token: bool) -> binder::public_api::Result<bool> { self.0.RepeatBoolean(_arg_token) }
RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8>1253 fn RepeatByte(&self, _arg_token: i8) -> binder::public_api::Result<i8> { self.0.RepeatByte(_arg_token) }
RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16>1254 fn RepeatChar(&self, _arg_token: u16) -> binder::public_api::Result<u16> { self.0.RepeatChar(_arg_token) }
RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32>1255 fn RepeatInt(&self, _arg_token: i32) -> binder::public_api::Result<i32> { self.0.RepeatInt(_arg_token) }
RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64>1256 fn RepeatLong(&self, _arg_token: i64) -> binder::public_api::Result<i64> { self.0.RepeatLong(_arg_token) }
RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32>1257 fn RepeatFloat(&self, _arg_token: f32) -> binder::public_api::Result<f32> { self.0.RepeatFloat(_arg_token) }
RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64>1258 fn RepeatDouble(&self, _arg_token: f64) -> binder::public_api::Result<f64> { self.0.RepeatDouble(_arg_token) }
RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String>1259 fn RepeatString(&self, _arg_token: &str) -> binder::public_api::Result<String> { self.0.RepeatString(_arg_token) }
RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>1260 fn RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> { self.0.RepeatByteEnum(_arg_token) }
RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>1261 fn RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> { self.0.RepeatIntEnum(_arg_token) }
RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>1262 fn RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> { self.0.RepeatLongEnum(_arg_token) }
ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>>1263 fn ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec<bool>) -> binder::public_api::Result<Vec<bool>> { self.0.ReverseBoolean(_arg_input, _arg_repeated) }
ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>>1264 fn ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec<u8>) -> binder::public_api::Result<Vec<u8>> { self.0.ReverseByte(_arg_input, _arg_repeated) }
ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>>1265 fn ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec<u16>) -> binder::public_api::Result<Vec<u16>> { self.0.ReverseChar(_arg_input, _arg_repeated) }
ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>>1266 fn ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec<i32>) -> binder::public_api::Result<Vec<i32>> { self.0.ReverseInt(_arg_input, _arg_repeated) }
ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>>1267 fn ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec<i64>) -> binder::public_api::Result<Vec<i64>> { self.0.ReverseLong(_arg_input, _arg_repeated) }
ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>>1268 fn ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec<f32>) -> binder::public_api::Result<Vec<f32>> { self.0.ReverseFloat(_arg_input, _arg_repeated) }
ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>>1269 fn ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec<f64>) -> binder::public_api::Result<Vec<f64>> { self.0.ReverseDouble(_arg_input, _arg_repeated) }
ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>1270 fn ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> { self.0.ReverseString(_arg_input, _arg_repeated) }
ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>1271 fn ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>> { self.0.ReverseByteEnum(_arg_input, _arg_repeated) }
ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>1272 fn ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>> { self.0.ReverseIntEnum(_arg_input, _arg_repeated) }
ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>1273 fn ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>) -> binder::public_api::Result<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>> { self.0.ReverseLongEnum(_arg_input, _arg_repeated) }
GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>1274 fn GetOtherTestService(&self, _arg_name: &str) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>> { self.0.GetOtherTestService(_arg_name) }
VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool>1275 fn VerifyName(&self, _arg_service: &binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>, _arg_name: &str) -> binder::public_api::Result<bool> { self.0.VerifyName(_arg_service, _arg_name) }
ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>1276 fn ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> { self.0.ReverseStringList(_arg_input, _arg_repeated) }
RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor>1277 fn RepeatParcelFileDescriptor(&self, _arg_read: &binder::parcel::ParcelFileDescriptor) -> binder::public_api::Result<binder::parcel::ParcelFileDescriptor> { self.0.RepeatParcelFileDescriptor(_arg_read) }
ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>>1278 fn ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::parcel::ParcelFileDescriptor], _arg_repeated: &mut Vec<Option<binder::parcel::ParcelFileDescriptor>>) -> binder::public_api::Result<Vec<binder::parcel::ParcelFileDescriptor>> { self.0.ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated) }
ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()>1279 fn ThrowServiceException(&self, _arg_code: i32) -> binder::public_api::Result<()> { self.0.ThrowServiceException(_arg_code) }
RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>>1280 fn RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::public_api::Result<Option<Vec<i32>>> { self.0.RepeatNullableIntArray(_arg_input) }
RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>>1281 fn RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>>> { self.0.RepeatNullableByteEnumArray(_arg_input) }
RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>>1282 fn RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>>> { self.0.RepeatNullableIntEnumArray(_arg_input) }
RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>>1283 fn RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::public_api::Result<Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>>> { self.0.RepeatNullableLongEnumArray(_arg_input) }
RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>>1284 fn RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::public_api::Result<Option<String>> { self.0.RepeatNullableString(_arg_input) }
RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>>1285 fn RepeatNullableStringList(&self, _arg_input: Option<&[Option<String>]>) -> binder::public_api::Result<Option<Vec<Option<String>>>> { self.0.RepeatNullableStringList(_arg_input) }
RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>>1286 fn RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>) -> binder::public_api::Result<Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable>> { self.0.RepeatNullableParcelable(_arg_input) }
TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()>1287 fn TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::public_api::Result<()> { self.0.TakesAnIBinder(_arg_input) }
TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()>1288 fn TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::public_api::Result<()> { self.0.TakesANullableIBinder(_arg_input) }
RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String>1289 fn RepeatUtf8CppString(&self, _arg_token: &str) -> binder::public_api::Result<String> { self.0.RepeatUtf8CppString(_arg_token) }
RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>>1290 fn RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::public_api::Result<Option<String>> { self.0.RepeatNullableUtf8CppString(_arg_token) }
ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>>1291 fn ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec<String>) -> binder::public_api::Result<Vec<String>> { self.0.ReverseUtf8CppString(_arg_input, _arg_repeated) }
ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>1292 fn ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> { self.0.ReverseNullableUtf8CppString(_arg_input, _arg_repeated) }
ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>>1293 fn ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option<String>]>, _arg_repeated: &mut Option<Vec<Option<String>>>) -> binder::public_api::Result<Option<Vec<Option<String>>>> { self.0.ReverseUtf8CppStringList(_arg_input, _arg_repeated) }
GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>>1294 fn GetCallback(&self, _arg_return_null: bool) -> binder::public_api::Result<Option<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback>>> { self.0.GetCallback(_arg_return_null) }
FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()>1295 fn FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::public_api::Result<()> { self.0.FillOutStructuredParcelable(_arg_parcel) }
GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>>1296 fn GetOldNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_IOldName>> { self.0.GetOldNameInterface() }
GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>>1297 fn GetNewNameInterface(&self) -> binder::public_api::Result<binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_8_INewName>> { self.0.GetNewNameInterface() }
GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>>1298 fn GetCppJavaTests(&self) -> binder::public_api::Result<Option<binder::SpIBinder>> { self.0.GetCppJavaTests() }
getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType>1299 fn getBackendType(&self) -> binder::public_api::Result<crate::mangled::_7_android_4_aidl_5_tests_11_BackendType> { self.0.getBackendType() }
1300 }
on_transact(_aidl_service: &dyn ITestService, _aidl_code: binder::TransactionCode, _aidl_data: &binder::parcel::Parcel, _aidl_reply: &mut binder::parcel::Parcel) -> binder::Result<()>1301 fn on_transact(_aidl_service: &dyn ITestService, _aidl_code: binder::TransactionCode, _aidl_data: &binder::parcel::Parcel, _aidl_reply: &mut binder::parcel::Parcel) -> binder::Result<()> {
1302 match _aidl_code {
1303 transactions::UnimplementedMethod => {
1304 let _arg_arg: i32 = _aidl_data.read()?;
1305 let _aidl_return = _aidl_service.UnimplementedMethod(_arg_arg);
1306 match &_aidl_return {
1307 Ok(_aidl_return) => {
1308 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1309 _aidl_reply.write(_aidl_return)?;
1310 }
1311 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1312 }
1313 Ok(())
1314 }
1315 transactions::Deprecated => {
1316 let _aidl_return = _aidl_service.Deprecated();
1317 match &_aidl_return {
1318 Ok(_aidl_return) => {
1319 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1320 }
1321 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1322 }
1323 Ok(())
1324 }
1325 transactions::TestOneway => {
1326 let _aidl_return = _aidl_service.TestOneway();
1327 Ok(())
1328 }
1329 transactions::RepeatBoolean => {
1330 let _arg_token: bool = _aidl_data.read()?;
1331 let _aidl_return = _aidl_service.RepeatBoolean(_arg_token);
1332 match &_aidl_return {
1333 Ok(_aidl_return) => {
1334 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1335 _aidl_reply.write(_aidl_return)?;
1336 }
1337 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1338 }
1339 Ok(())
1340 }
1341 transactions::RepeatByte => {
1342 let _arg_token: i8 = _aidl_data.read()?;
1343 let _aidl_return = _aidl_service.RepeatByte(_arg_token);
1344 match &_aidl_return {
1345 Ok(_aidl_return) => {
1346 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1347 _aidl_reply.write(_aidl_return)?;
1348 }
1349 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1350 }
1351 Ok(())
1352 }
1353 transactions::RepeatChar => {
1354 let _arg_token: u16 = _aidl_data.read()?;
1355 let _aidl_return = _aidl_service.RepeatChar(_arg_token);
1356 match &_aidl_return {
1357 Ok(_aidl_return) => {
1358 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1359 _aidl_reply.write(_aidl_return)?;
1360 }
1361 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1362 }
1363 Ok(())
1364 }
1365 transactions::RepeatInt => {
1366 let _arg_token: i32 = _aidl_data.read()?;
1367 let _aidl_return = _aidl_service.RepeatInt(_arg_token);
1368 match &_aidl_return {
1369 Ok(_aidl_return) => {
1370 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1371 _aidl_reply.write(_aidl_return)?;
1372 }
1373 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1374 }
1375 Ok(())
1376 }
1377 transactions::RepeatLong => {
1378 let _arg_token: i64 = _aidl_data.read()?;
1379 let _aidl_return = _aidl_service.RepeatLong(_arg_token);
1380 match &_aidl_return {
1381 Ok(_aidl_return) => {
1382 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1383 _aidl_reply.write(_aidl_return)?;
1384 }
1385 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1386 }
1387 Ok(())
1388 }
1389 transactions::RepeatFloat => {
1390 let _arg_token: f32 = _aidl_data.read()?;
1391 let _aidl_return = _aidl_service.RepeatFloat(_arg_token);
1392 match &_aidl_return {
1393 Ok(_aidl_return) => {
1394 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1395 _aidl_reply.write(_aidl_return)?;
1396 }
1397 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1398 }
1399 Ok(())
1400 }
1401 transactions::RepeatDouble => {
1402 let _arg_token: f64 = _aidl_data.read()?;
1403 let _aidl_return = _aidl_service.RepeatDouble(_arg_token);
1404 match &_aidl_return {
1405 Ok(_aidl_return) => {
1406 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1407 _aidl_reply.write(_aidl_return)?;
1408 }
1409 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1410 }
1411 Ok(())
1412 }
1413 transactions::RepeatString => {
1414 let _arg_token: String = _aidl_data.read()?;
1415 let _aidl_return = _aidl_service.RepeatString(&_arg_token);
1416 match &_aidl_return {
1417 Ok(_aidl_return) => {
1418 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1419 _aidl_reply.write(_aidl_return)?;
1420 }
1421 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1422 }
1423 Ok(())
1424 }
1425 transactions::RepeatByteEnum => {
1426 let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_data.read()?;
1427 let _aidl_return = _aidl_service.RepeatByteEnum(_arg_token);
1428 match &_aidl_return {
1429 Ok(_aidl_return) => {
1430 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1431 _aidl_reply.write(_aidl_return)?;
1432 }
1433 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1434 }
1435 Ok(())
1436 }
1437 transactions::RepeatIntEnum => {
1438 let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_data.read()?;
1439 let _aidl_return = _aidl_service.RepeatIntEnum(_arg_token);
1440 match &_aidl_return {
1441 Ok(_aidl_return) => {
1442 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1443 _aidl_reply.write(_aidl_return)?;
1444 }
1445 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1446 }
1447 Ok(())
1448 }
1449 transactions::RepeatLongEnum => {
1450 let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_data.read()?;
1451 let _aidl_return = _aidl_service.RepeatLongEnum(_arg_token);
1452 match &_aidl_return {
1453 Ok(_aidl_return) => {
1454 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1455 _aidl_reply.write(_aidl_return)?;
1456 }
1457 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1458 }
1459 Ok(())
1460 }
1461 transactions::ReverseBoolean => {
1462 let _arg_input: Vec<bool> = _aidl_data.read()?;
1463 let mut _arg_repeated: Vec<bool> = Default::default();
1464 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1465 let _aidl_return = _aidl_service.ReverseBoolean(&_arg_input, &mut _arg_repeated);
1466 match &_aidl_return {
1467 Ok(_aidl_return) => {
1468 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1469 _aidl_reply.write(_aidl_return)?;
1470 _aidl_reply.write(&_arg_repeated)?;
1471 }
1472 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1473 }
1474 Ok(())
1475 }
1476 transactions::ReverseByte => {
1477 let _arg_input: Vec<u8> = _aidl_data.read()?;
1478 let mut _arg_repeated: Vec<u8> = Default::default();
1479 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1480 let _aidl_return = _aidl_service.ReverseByte(&_arg_input, &mut _arg_repeated);
1481 match &_aidl_return {
1482 Ok(_aidl_return) => {
1483 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1484 _aidl_reply.write(_aidl_return)?;
1485 _aidl_reply.write(&_arg_repeated)?;
1486 }
1487 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1488 }
1489 Ok(())
1490 }
1491 transactions::ReverseChar => {
1492 let _arg_input: Vec<u16> = _aidl_data.read()?;
1493 let mut _arg_repeated: Vec<u16> = Default::default();
1494 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1495 let _aidl_return = _aidl_service.ReverseChar(&_arg_input, &mut _arg_repeated);
1496 match &_aidl_return {
1497 Ok(_aidl_return) => {
1498 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1499 _aidl_reply.write(_aidl_return)?;
1500 _aidl_reply.write(&_arg_repeated)?;
1501 }
1502 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1503 }
1504 Ok(())
1505 }
1506 transactions::ReverseInt => {
1507 let _arg_input: Vec<i32> = _aidl_data.read()?;
1508 let mut _arg_repeated: Vec<i32> = Default::default();
1509 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1510 let _aidl_return = _aidl_service.ReverseInt(&_arg_input, &mut _arg_repeated);
1511 match &_aidl_return {
1512 Ok(_aidl_return) => {
1513 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1514 _aidl_reply.write(_aidl_return)?;
1515 _aidl_reply.write(&_arg_repeated)?;
1516 }
1517 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1518 }
1519 Ok(())
1520 }
1521 transactions::ReverseLong => {
1522 let _arg_input: Vec<i64> = _aidl_data.read()?;
1523 let mut _arg_repeated: Vec<i64> = Default::default();
1524 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1525 let _aidl_return = _aidl_service.ReverseLong(&_arg_input, &mut _arg_repeated);
1526 match &_aidl_return {
1527 Ok(_aidl_return) => {
1528 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1529 _aidl_reply.write(_aidl_return)?;
1530 _aidl_reply.write(&_arg_repeated)?;
1531 }
1532 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1533 }
1534 Ok(())
1535 }
1536 transactions::ReverseFloat => {
1537 let _arg_input: Vec<f32> = _aidl_data.read()?;
1538 let mut _arg_repeated: Vec<f32> = Default::default();
1539 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1540 let _aidl_return = _aidl_service.ReverseFloat(&_arg_input, &mut _arg_repeated);
1541 match &_aidl_return {
1542 Ok(_aidl_return) => {
1543 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1544 _aidl_reply.write(_aidl_return)?;
1545 _aidl_reply.write(&_arg_repeated)?;
1546 }
1547 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1548 }
1549 Ok(())
1550 }
1551 transactions::ReverseDouble => {
1552 let _arg_input: Vec<f64> = _aidl_data.read()?;
1553 let mut _arg_repeated: Vec<f64> = Default::default();
1554 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1555 let _aidl_return = _aidl_service.ReverseDouble(&_arg_input, &mut _arg_repeated);
1556 match &_aidl_return {
1557 Ok(_aidl_return) => {
1558 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1559 _aidl_reply.write(_aidl_return)?;
1560 _aidl_reply.write(&_arg_repeated)?;
1561 }
1562 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1563 }
1564 Ok(())
1565 }
1566 transactions::ReverseString => {
1567 let _arg_input: Vec<String> = _aidl_data.read()?;
1568 let mut _arg_repeated: Vec<String> = Default::default();
1569 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1570 let _aidl_return = _aidl_service.ReverseString(&_arg_input, &mut _arg_repeated);
1571 match &_aidl_return {
1572 Ok(_aidl_return) => {
1573 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1574 _aidl_reply.write(_aidl_return)?;
1575 _aidl_reply.write(&_arg_repeated)?;
1576 }
1577 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1578 }
1579 Ok(())
1580 }
1581 transactions::ReverseByteEnum => {
1582 let _arg_input: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> = _aidl_data.read()?;
1583 let mut _arg_repeated: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum> = Default::default();
1584 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1585 let _aidl_return = _aidl_service.ReverseByteEnum(&_arg_input, &mut _arg_repeated);
1586 match &_aidl_return {
1587 Ok(_aidl_return) => {
1588 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1589 _aidl_reply.write(_aidl_return)?;
1590 _aidl_reply.write(&_arg_repeated)?;
1591 }
1592 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1593 }
1594 Ok(())
1595 }
1596 transactions::ReverseIntEnum => {
1597 let _arg_input: Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> = _aidl_data.read()?;
1598 let mut _arg_repeated: Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum> = Default::default();
1599 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1600 let _aidl_return = _aidl_service.ReverseIntEnum(&_arg_input, &mut _arg_repeated);
1601 match &_aidl_return {
1602 Ok(_aidl_return) => {
1603 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1604 _aidl_reply.write(_aidl_return)?;
1605 _aidl_reply.write(&_arg_repeated)?;
1606 }
1607 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1608 }
1609 Ok(())
1610 }
1611 transactions::ReverseLongEnum => {
1612 let _arg_input: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> = _aidl_data.read()?;
1613 let mut _arg_repeated: Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum> = Default::default();
1614 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1615 let _aidl_return = _aidl_service.ReverseLongEnum(&_arg_input, &mut _arg_repeated);
1616 match &_aidl_return {
1617 Ok(_aidl_return) => {
1618 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1619 _aidl_reply.write(_aidl_return)?;
1620 _aidl_reply.write(&_arg_repeated)?;
1621 }
1622 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1623 }
1624 Ok(())
1625 }
1626 transactions::GetOtherTestService => {
1627 let _arg_name: String = _aidl_data.read()?;
1628 let _aidl_return = _aidl_service.GetOtherTestService(&_arg_name);
1629 match &_aidl_return {
1630 Ok(_aidl_return) => {
1631 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1632 _aidl_reply.write(_aidl_return)?;
1633 }
1634 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1635 }
1636 Ok(())
1637 }
1638 transactions::VerifyName => {
1639 let _arg_service: binder::Strong<dyn crate::mangled::_7_android_4_aidl_5_tests_14_INamedCallback> = _aidl_data.read()?;
1640 let _arg_name: String = _aidl_data.read()?;
1641 let _aidl_return = _aidl_service.VerifyName(&_arg_service, &_arg_name);
1642 match &_aidl_return {
1643 Ok(_aidl_return) => {
1644 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1645 _aidl_reply.write(_aidl_return)?;
1646 }
1647 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1648 }
1649 Ok(())
1650 }
1651 transactions::ReverseStringList => {
1652 let _arg_input: Vec<String> = _aidl_data.read()?;
1653 let mut _arg_repeated: Vec<String> = Default::default();
1654 let _aidl_return = _aidl_service.ReverseStringList(&_arg_input, &mut _arg_repeated);
1655 match &_aidl_return {
1656 Ok(_aidl_return) => {
1657 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1658 _aidl_reply.write(_aidl_return)?;
1659 _aidl_reply.write(&_arg_repeated)?;
1660 }
1661 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1662 }
1663 Ok(())
1664 }
1665 transactions::RepeatParcelFileDescriptor => {
1666 let _arg_read: binder::parcel::ParcelFileDescriptor = _aidl_data.read()?;
1667 let _aidl_return = _aidl_service.RepeatParcelFileDescriptor(&_arg_read);
1668 match &_aidl_return {
1669 Ok(_aidl_return) => {
1670 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1671 _aidl_reply.write(_aidl_return)?;
1672 }
1673 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1674 }
1675 Ok(())
1676 }
1677 transactions::ReverseParcelFileDescriptorArray => {
1678 let _arg_input: Vec<binder::parcel::ParcelFileDescriptor> = _aidl_data.read()?;
1679 let mut _arg_repeated: Vec<Option<binder::parcel::ParcelFileDescriptor>> = Default::default();
1680 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1681 let _aidl_return = _aidl_service.ReverseParcelFileDescriptorArray(&_arg_input, &mut _arg_repeated);
1682 match &_aidl_return {
1683 Ok(_aidl_return) => {
1684 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1685 _aidl_reply.write(_aidl_return)?;
1686 if _arg_repeated.iter().any(Option::is_none) { return Err(binder::StatusCode::UNEXPECTED_NULL); }
1687 _aidl_reply.write(&_arg_repeated)?;
1688 }
1689 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1690 }
1691 Ok(())
1692 }
1693 transactions::ThrowServiceException => {
1694 let _arg_code: i32 = _aidl_data.read()?;
1695 let _aidl_return = _aidl_service.ThrowServiceException(_arg_code);
1696 match &_aidl_return {
1697 Ok(_aidl_return) => {
1698 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1699 }
1700 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1701 }
1702 Ok(())
1703 }
1704 transactions::RepeatNullableIntArray => {
1705 let _arg_input: Option<Vec<i32>> = _aidl_data.read()?;
1706 let _aidl_return = _aidl_service.RepeatNullableIntArray(_arg_input.as_deref());
1707 match &_aidl_return {
1708 Ok(_aidl_return) => {
1709 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1710 _aidl_reply.write(_aidl_return)?;
1711 }
1712 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1713 }
1714 Ok(())
1715 }
1716 transactions::RepeatNullableByteEnumArray => {
1717 let _arg_input: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum>> = _aidl_data.read()?;
1718 let _aidl_return = _aidl_service.RepeatNullableByteEnumArray(_arg_input.as_deref());
1719 match &_aidl_return {
1720 Ok(_aidl_return) => {
1721 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1722 _aidl_reply.write(_aidl_return)?;
1723 }
1724 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1725 }
1726 Ok(())
1727 }
1728 transactions::RepeatNullableIntEnumArray => {
1729 let _arg_input: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum>> = _aidl_data.read()?;
1730 let _aidl_return = _aidl_service.RepeatNullableIntEnumArray(_arg_input.as_deref());
1731 match &_aidl_return {
1732 Ok(_aidl_return) => {
1733 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1734 _aidl_reply.write(_aidl_return)?;
1735 }
1736 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1737 }
1738 Ok(())
1739 }
1740 transactions::RepeatNullableLongEnumArray => {
1741 let _arg_input: Option<Vec<crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum>> = _aidl_data.read()?;
1742 let _aidl_return = _aidl_service.RepeatNullableLongEnumArray(_arg_input.as_deref());
1743 match &_aidl_return {
1744 Ok(_aidl_return) => {
1745 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1746 _aidl_reply.write(_aidl_return)?;
1747 }
1748 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1749 }
1750 Ok(())
1751 }
1752 transactions::RepeatNullableString => {
1753 let _arg_input: Option<String> = _aidl_data.read()?;
1754 let _aidl_return = _aidl_service.RepeatNullableString(_arg_input.as_deref());
1755 match &_aidl_return {
1756 Ok(_aidl_return) => {
1757 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1758 _aidl_reply.write(_aidl_return)?;
1759 }
1760 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1761 }
1762 Ok(())
1763 }
1764 transactions::RepeatNullableStringList => {
1765 let _arg_input: Option<Vec<Option<String>>> = _aidl_data.read()?;
1766 let _aidl_return = _aidl_service.RepeatNullableStringList(_arg_input.as_deref());
1767 match &_aidl_return {
1768 Ok(_aidl_return) => {
1769 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1770 _aidl_reply.write(_aidl_return)?;
1771 }
1772 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1773 }
1774 Ok(())
1775 }
1776 transactions::RepeatNullableParcelable => {
1777 let _arg_input: Option<crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable> = _aidl_data.read()?;
1778 let _aidl_return = _aidl_service.RepeatNullableParcelable(_arg_input.as_ref());
1779 match &_aidl_return {
1780 Ok(_aidl_return) => {
1781 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1782 _aidl_reply.write(_aidl_return)?;
1783 }
1784 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1785 }
1786 Ok(())
1787 }
1788 transactions::TakesAnIBinder => {
1789 let _arg_input: binder::SpIBinder = _aidl_data.read()?;
1790 let _aidl_return = _aidl_service.TakesAnIBinder(&_arg_input);
1791 match &_aidl_return {
1792 Ok(_aidl_return) => {
1793 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1794 }
1795 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1796 }
1797 Ok(())
1798 }
1799 transactions::TakesANullableIBinder => {
1800 let _arg_input: Option<binder::SpIBinder> = _aidl_data.read()?;
1801 let _aidl_return = _aidl_service.TakesANullableIBinder(_arg_input.as_ref());
1802 match &_aidl_return {
1803 Ok(_aidl_return) => {
1804 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1805 }
1806 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1807 }
1808 Ok(())
1809 }
1810 transactions::RepeatUtf8CppString => {
1811 let _arg_token: String = _aidl_data.read()?;
1812 let _aidl_return = _aidl_service.RepeatUtf8CppString(&_arg_token);
1813 match &_aidl_return {
1814 Ok(_aidl_return) => {
1815 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1816 _aidl_reply.write(_aidl_return)?;
1817 }
1818 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1819 }
1820 Ok(())
1821 }
1822 transactions::RepeatNullableUtf8CppString => {
1823 let _arg_token: Option<String> = _aidl_data.read()?;
1824 let _aidl_return = _aidl_service.RepeatNullableUtf8CppString(_arg_token.as_deref());
1825 match &_aidl_return {
1826 Ok(_aidl_return) => {
1827 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1828 _aidl_reply.write(_aidl_return)?;
1829 }
1830 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1831 }
1832 Ok(())
1833 }
1834 transactions::ReverseUtf8CppString => {
1835 let _arg_input: Vec<String> = _aidl_data.read()?;
1836 let mut _arg_repeated: Vec<String> = Default::default();
1837 _aidl_data.resize_out_vec(&mut _arg_repeated)?;
1838 let _aidl_return = _aidl_service.ReverseUtf8CppString(&_arg_input, &mut _arg_repeated);
1839 match &_aidl_return {
1840 Ok(_aidl_return) => {
1841 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1842 _aidl_reply.write(_aidl_return)?;
1843 _aidl_reply.write(&_arg_repeated)?;
1844 }
1845 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1846 }
1847 Ok(())
1848 }
1849 transactions::ReverseNullableUtf8CppString => {
1850 let _arg_input: Option<Vec<Option<String>>> = _aidl_data.read()?;
1851 let mut _arg_repeated: Option<Vec<Option<String>>> = Default::default();
1852 _aidl_data.resize_nullable_out_vec(&mut _arg_repeated)?;
1853 let _aidl_return = _aidl_service.ReverseNullableUtf8CppString(_arg_input.as_deref(), &mut _arg_repeated);
1854 match &_aidl_return {
1855 Ok(_aidl_return) => {
1856 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1857 _aidl_reply.write(_aidl_return)?;
1858 _aidl_reply.write(&_arg_repeated)?;
1859 }
1860 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1861 }
1862 Ok(())
1863 }
1864 transactions::ReverseUtf8CppStringList => {
1865 let _arg_input: Option<Vec<Option<String>>> = _aidl_data.read()?;
1866 let mut _arg_repeated: Option<Vec<Option<String>>> = Default::default();
1867 let _aidl_return = _aidl_service.ReverseUtf8CppStringList(_arg_input.as_deref(), &mut _arg_repeated);
1868 match &_aidl_return {
1869 Ok(_aidl_return) => {
1870 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1871 _aidl_reply.write(_aidl_return)?;
1872 _aidl_reply.write(&_arg_repeated)?;
1873 }
1874 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1875 }
1876 Ok(())
1877 }
1878 transactions::GetCallback => {
1879 let _arg_return_null: bool = _aidl_data.read()?;
1880 let _aidl_return = _aidl_service.GetCallback(_arg_return_null);
1881 match &_aidl_return {
1882 Ok(_aidl_return) => {
1883 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1884 _aidl_reply.write(_aidl_return)?;
1885 }
1886 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1887 }
1888 Ok(())
1889 }
1890 transactions::FillOutStructuredParcelable => {
1891 let mut _arg_parcel: crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable = _aidl_data.read()?;
1892 let _aidl_return = _aidl_service.FillOutStructuredParcelable(&mut _arg_parcel);
1893 match &_aidl_return {
1894 Ok(_aidl_return) => {
1895 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1896 _aidl_reply.write(&_arg_parcel)?;
1897 }
1898 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1899 }
1900 Ok(())
1901 }
1902 transactions::GetOldNameInterface => {
1903 let _aidl_return = _aidl_service.GetOldNameInterface();
1904 match &_aidl_return {
1905 Ok(_aidl_return) => {
1906 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1907 _aidl_reply.write(_aidl_return)?;
1908 }
1909 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1910 }
1911 Ok(())
1912 }
1913 transactions::GetNewNameInterface => {
1914 let _aidl_return = _aidl_service.GetNewNameInterface();
1915 match &_aidl_return {
1916 Ok(_aidl_return) => {
1917 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1918 _aidl_reply.write(_aidl_return)?;
1919 }
1920 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1921 }
1922 Ok(())
1923 }
1924 transactions::GetCppJavaTests => {
1925 let _aidl_return = _aidl_service.GetCppJavaTests();
1926 match &_aidl_return {
1927 Ok(_aidl_return) => {
1928 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1929 _aidl_reply.write(_aidl_return)?;
1930 }
1931 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1932 }
1933 Ok(())
1934 }
1935 transactions::getBackendType => {
1936 let _aidl_return = _aidl_service.getBackendType();
1937 match &_aidl_return {
1938 Ok(_aidl_return) => {
1939 _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;
1940 _aidl_reply.write(_aidl_return)?;
1941 }
1942 Err(_aidl_status) => _aidl_reply.write(_aidl_status)?
1943 }
1944 Ok(())
1945 }
1946 _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION)
1947 }
1948 }
1949