Google Git
Sign in
android / platform / prebuilts / vndk / v30 / 83b9ce8ff76062bfd3507f6f0189f08906eb28f6 / . / arm / include / out / soong / .intermediates / hardware / interfaces / radio / 1.1 / android.hardware.radio@1.1_genc++_headers / gen / android / hardware / radio / 1.1 / BsRadioResponse.h
blob: 40fd67e4d95a7afe3de71f42e702f5d6ceac9737 [file] [log] [blame]
#ifndef HIDL_GENERATED_ANDROID_HARDWARE_RADIO_V1_1_BSRADIORESPONSE_H
#define HIDL_GENERATED_ANDROID_HARDWARE_RADIO_V1_1_BSRADIORESPONSE_H
#include <android-base/macros.h>
#include <cutils/trace.h>
#include <future>
#include <android/hardware/radio/1.1/IRadioResponse.h>
#include <hidl/HidlPassthroughSupport.h>
#include <hidl/TaskRunner.h>
namespace android {
namespace hardware {
namespace radio {
namespace V1_1 {
struct BsRadioResponse : IRadioResponse, ::android::hardware::details::HidlInstrumentor {
explicit BsRadioResponse(const ::android::sp<IRadioResponse> impl);
/**
* The pure class is what this class wraps.
*/
typedef IRadioResponse Pure;
typedef ::android::hardware::details::bs_tag _hidl_tag;
// Methods from ::android::hardware::radio::V1_0::IRadioResponse follow.
::android::hardware::Return<void> getIccCardStatusResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::CardStatus& cardStatus) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getIccCardStatusResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&cardStatus);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getIccCardStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, cardStatus] {
mImpl->getIccCardStatusResponse(info, cardStatus);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getIccCardStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> supplyIccPinForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::supplyIccPinForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPinForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->supplyIccPinForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPinForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> supplyIccPukForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::supplyIccPukForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPukForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->supplyIccPukForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPukForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> supplyIccPin2ForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::supplyIccPin2ForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPin2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->supplyIccPin2ForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPin2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> supplyIccPuk2ForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::supplyIccPuk2ForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPuk2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->supplyIccPuk2ForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "supplyIccPuk2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> changeIccPinForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::changeIccPinForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "changeIccPinForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->changeIccPinForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "changeIccPinForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> changeIccPin2ForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::changeIccPin2ForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "changeIccPin2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->changeIccPin2ForAppResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "changeIccPin2ForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> supplyNetworkDepersonalizationResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t remainingRetries) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::supplyNetworkDepersonalizationResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&remainingRetries);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "supplyNetworkDepersonalizationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, remainingRetries] {
mImpl->supplyNetworkDepersonalizationResponse(info, remainingRetries);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "supplyNetworkDepersonalizationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCurrentCallsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::Call>& calls) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCurrentCallsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&calls);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCurrentCallsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, calls] {
mImpl->getCurrentCallsResponse(info, calls);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCurrentCallsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> dialResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::dialResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "dialResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->dialResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "dialResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getIMSIForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& imsi) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getIMSIForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&imsi);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getIMSIForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, imsi] {
mImpl->getIMSIForAppResponse(info, imsi);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getIMSIForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> hangupConnectionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::hangupConnectionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "hangupConnectionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->hangupConnectionResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "hangupConnectionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> hangupWaitingOrBackgroundResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::hangupWaitingOrBackgroundResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "hangupWaitingOrBackgroundResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->hangupWaitingOrBackgroundResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "hangupWaitingOrBackgroundResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> hangupForegroundResumeBackgroundResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::hangupForegroundResumeBackgroundResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "hangupForegroundResumeBackgroundResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->hangupForegroundResumeBackgroundResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "hangupForegroundResumeBackgroundResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> switchWaitingOrHoldingAndActiveResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::switchWaitingOrHoldingAndActiveResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "switchWaitingOrHoldingAndActiveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->switchWaitingOrHoldingAndActiveResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "switchWaitingOrHoldingAndActiveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> conferenceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::conferenceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "conferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->conferenceResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "conferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> rejectCallResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::rejectCallResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "rejectCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->rejectCallResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "rejectCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getLastCallFailCauseResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::LastCallFailCauseInfo& failCauseinfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getLastCallFailCauseResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&failCauseinfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getLastCallFailCauseResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, failCauseinfo] {
mImpl->getLastCallFailCauseResponse(info, failCauseinfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getLastCallFailCauseResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getSignalStrengthResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SignalStrength& sigStrength) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getSignalStrengthResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&sigStrength);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getSignalStrengthResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, sigStrength] {
mImpl->getSignalStrengthResponse(info, sigStrength);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getSignalStrengthResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getVoiceRegistrationStateResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::VoiceRegStateResult& voiceRegResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getVoiceRegistrationStateResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&voiceRegResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getVoiceRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, voiceRegResponse] {
mImpl->getVoiceRegistrationStateResponse(info, voiceRegResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getVoiceRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getDataRegistrationStateResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::DataRegStateResult& dataRegResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getDataRegistrationStateResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&dataRegResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getDataRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, dataRegResponse] {
mImpl->getDataRegistrationStateResponse(info, dataRegResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getDataRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getOperatorResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& longName, const ::android::hardware::hidl_string& shortName, const ::android::hardware::hidl_string& numeric) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getOperatorResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&longName);
_hidl_args.push_back((void *)&shortName);
_hidl_args.push_back((void *)&numeric);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getOperatorResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, longName, shortName, numeric] {
mImpl->getOperatorResponse(info, longName, shortName, numeric);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getOperatorResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setRadioPowerResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setRadioPowerResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setRadioPowerResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setRadioPowerResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setRadioPowerResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendDtmfResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendDtmfResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendDtmfResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendSmsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SendSmsResult& sms) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendSmsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&sms);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, sms] {
mImpl->sendSmsResponse(info, sms);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendSMSExpectMoreResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SendSmsResult& sms) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendSMSExpectMoreResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&sms);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendSMSExpectMoreResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, sms] {
mImpl->sendSMSExpectMoreResponse(info, sms);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendSMSExpectMoreResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setupDataCallResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SetupDataCallResult& dcResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setupDataCallResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&dcResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setupDataCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, dcResponse] {
mImpl->setupDataCallResponse(info, dcResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setupDataCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> iccIOForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::IccIoResult& iccIo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::iccIOForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&iccIo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "iccIOForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, iccIo] {
mImpl->iccIOForAppResponse(info, iccIo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "iccIOForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendUssdResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendUssdResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendUssdResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendUssdResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendUssdResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> cancelPendingUssdResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::cancelPendingUssdResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "cancelPendingUssdResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->cancelPendingUssdResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "cancelPendingUssdResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getClirResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t n, int32_t m) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getClirResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&n);
_hidl_args.push_back((void *)&m);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getClirResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, n, m] {
mImpl->getClirResponse(info, n, m);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getClirResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setClirResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setClirResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setClirResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setClirResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setClirResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCallForwardStatusResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::CallForwardInfo>& callForwardInfos) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCallForwardStatusResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&callForwardInfos);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCallForwardStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, callForwardInfos] {
mImpl->getCallForwardStatusResponse(info, callForwardInfos);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCallForwardStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCallForwardResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCallForwardResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCallForwardResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCallForwardResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCallForwardResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCallWaitingResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool enable, int32_t serviceClass) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCallWaitingResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&enable);
_hidl_args.push_back((void *)&serviceClass);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCallWaitingResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, enable, serviceClass] {
mImpl->getCallWaitingResponse(info, enable, serviceClass);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCallWaitingResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCallWaitingResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCallWaitingResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCallWaitingResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCallWaitingResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCallWaitingResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> acknowledgeLastIncomingGsmSmsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::acknowledgeLastIncomingGsmSmsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeLastIncomingGsmSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->acknowledgeLastIncomingGsmSmsResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeLastIncomingGsmSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> acceptCallResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::acceptCallResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "acceptCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->acceptCallResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "acceptCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> deactivateDataCallResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::deactivateDataCallResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "deactivateDataCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->deactivateDataCallResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "deactivateDataCallResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getFacilityLockForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t response) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getFacilityLockForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&response);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getFacilityLockForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, response] {
mImpl->getFacilityLockForAppResponse(info, response);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getFacilityLockForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setFacilityLockForAppResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t retry) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setFacilityLockForAppResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&retry);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setFacilityLockForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, retry] {
mImpl->setFacilityLockForAppResponse(info, retry);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setFacilityLockForAppResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setBarringPasswordResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setBarringPasswordResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setBarringPasswordResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setBarringPasswordResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setBarringPasswordResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getNetworkSelectionModeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool manual) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getNetworkSelectionModeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&manual);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getNetworkSelectionModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, manual] {
mImpl->getNetworkSelectionModeResponse(info, manual);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getNetworkSelectionModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setNetworkSelectionModeAutomaticResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setNetworkSelectionModeAutomaticResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setNetworkSelectionModeAutomaticResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setNetworkSelectionModeAutomaticResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setNetworkSelectionModeAutomaticResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setNetworkSelectionModeManualResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setNetworkSelectionModeManualResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setNetworkSelectionModeManualResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setNetworkSelectionModeManualResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setNetworkSelectionModeManualResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getAvailableNetworksResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::OperatorInfo>& networkInfos) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getAvailableNetworksResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&networkInfos);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getAvailableNetworksResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, networkInfos] {
mImpl->getAvailableNetworksResponse(info, networkInfos);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getAvailableNetworksResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> startDtmfResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::startDtmfResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "startDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->startDtmfResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "startDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> stopDtmfResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::stopDtmfResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "stopDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->stopDtmfResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "stopDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getBasebandVersionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& version) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getBasebandVersionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&version);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getBasebandVersionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, version] {
mImpl->getBasebandVersionResponse(info, version);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getBasebandVersionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> separateConnectionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::separateConnectionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "separateConnectionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->separateConnectionResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "separateConnectionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setMuteResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setMuteResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setMuteResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setMuteResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setMuteResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getMuteResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool enable) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getMuteResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&enable);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getMuteResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, enable] {
mImpl->getMuteResponse(info, enable);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getMuteResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getClipResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::ClipStatus status) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getClipResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&status);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getClipResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, status] {
mImpl->getClipResponse(info, status);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getClipResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getDataCallListResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::SetupDataCallResult>& dcResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getDataCallListResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&dcResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getDataCallListResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, dcResponse] {
mImpl->getDataCallListResponse(info, dcResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getDataCallListResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setSuppServiceNotificationsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setSuppServiceNotificationsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setSuppServiceNotificationsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setSuppServiceNotificationsResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setSuppServiceNotificationsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> writeSmsToSimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t index) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::writeSmsToSimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&index);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "writeSmsToSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, index] {
mImpl->writeSmsToSimResponse(info, index);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "writeSmsToSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> deleteSmsOnSimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::deleteSmsOnSimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "deleteSmsOnSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->deleteSmsOnSimResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "deleteSmsOnSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setBandModeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setBandModeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setBandModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setBandModeResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setBandModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getAvailableBandModesResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::RadioBandMode>& bandModes) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getAvailableBandModesResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&bandModes);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getAvailableBandModesResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, bandModes] {
mImpl->getAvailableBandModesResponse(info, bandModes);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getAvailableBandModesResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendEnvelopeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& commandResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendEnvelopeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&commandResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendEnvelopeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, commandResponse] {
mImpl->sendEnvelopeResponse(info, commandResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendEnvelopeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendTerminalResponseToSimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendTerminalResponseToSimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendTerminalResponseToSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendTerminalResponseToSimResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendTerminalResponseToSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> handleStkCallSetupRequestFromSimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::handleStkCallSetupRequestFromSimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "handleStkCallSetupRequestFromSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->handleStkCallSetupRequestFromSimResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "handleStkCallSetupRequestFromSimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> explicitCallTransferResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::explicitCallTransferResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "explicitCallTransferResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->explicitCallTransferResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "explicitCallTransferResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setPreferredNetworkTypeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setPreferredNetworkTypeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setPreferredNetworkTypeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setPreferredNetworkTypeResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setPreferredNetworkTypeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getPreferredNetworkTypeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::PreferredNetworkType nwType) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getPreferredNetworkTypeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&nwType);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getPreferredNetworkTypeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, nwType] {
mImpl->getPreferredNetworkTypeResponse(info, nwType);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getPreferredNetworkTypeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getNeighboringCidsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::NeighboringCell>& cells) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getNeighboringCidsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&cells);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getNeighboringCidsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, cells] {
mImpl->getNeighboringCidsResponse(info, cells);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getNeighboringCidsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setLocationUpdatesResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setLocationUpdatesResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setLocationUpdatesResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setLocationUpdatesResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setLocationUpdatesResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCdmaSubscriptionSourceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCdmaSubscriptionSourceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaSubscriptionSourceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCdmaSubscriptionSourceResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaSubscriptionSourceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCdmaRoamingPreferenceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCdmaRoamingPreferenceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaRoamingPreferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCdmaRoamingPreferenceResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaRoamingPreferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCdmaRoamingPreferenceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::CdmaRoamingType type) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCdmaRoamingPreferenceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&type);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaRoamingPreferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, type] {
mImpl->getCdmaRoamingPreferenceResponse(info, type);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaRoamingPreferenceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setTTYModeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setTTYModeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setTTYModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setTTYModeResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setTTYModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getTTYModeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::TtyMode mode) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getTTYModeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&mode);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getTTYModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, mode] {
mImpl->getTTYModeResponse(info, mode);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getTTYModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setPreferredVoicePrivacyResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setPreferredVoicePrivacyResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setPreferredVoicePrivacyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setPreferredVoicePrivacyResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setPreferredVoicePrivacyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getPreferredVoicePrivacyResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool enable) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getPreferredVoicePrivacyResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&enable);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getPreferredVoicePrivacyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, enable] {
mImpl->getPreferredVoicePrivacyResponse(info, enable);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getPreferredVoicePrivacyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendCDMAFeatureCodeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendCDMAFeatureCodeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendCDMAFeatureCodeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendCDMAFeatureCodeResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendCDMAFeatureCodeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendBurstDtmfResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendBurstDtmfResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendBurstDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendBurstDtmfResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendBurstDtmfResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendCdmaSmsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SendSmsResult& sms) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendCdmaSmsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&sms);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendCdmaSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, sms] {
mImpl->sendCdmaSmsResponse(info, sms);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendCdmaSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> acknowledgeLastIncomingCdmaSmsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::acknowledgeLastIncomingCdmaSmsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeLastIncomingCdmaSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->acknowledgeLastIncomingCdmaSmsResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeLastIncomingCdmaSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getGsmBroadcastConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::GsmBroadcastSmsConfigInfo>& configs) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getGsmBroadcastConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&configs);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getGsmBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, configs] {
mImpl->getGsmBroadcastConfigResponse(info, configs);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getGsmBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setGsmBroadcastConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setGsmBroadcastConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setGsmBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setGsmBroadcastConfigResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setGsmBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setGsmBroadcastActivationResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setGsmBroadcastActivationResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setGsmBroadcastActivationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setGsmBroadcastActivationResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setGsmBroadcastActivationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCdmaBroadcastConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::CdmaBroadcastSmsConfigInfo>& configs) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCdmaBroadcastConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&configs);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, configs] {
mImpl->getCdmaBroadcastConfigResponse(info, configs);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCdmaBroadcastConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCdmaBroadcastConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCdmaBroadcastConfigResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaBroadcastConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCdmaBroadcastActivationResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCdmaBroadcastActivationResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaBroadcastActivationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCdmaBroadcastActivationResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCdmaBroadcastActivationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCDMASubscriptionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& mdn, const ::android::hardware::hidl_string& hSid, const ::android::hardware::hidl_string& hNid, const ::android::hardware::hidl_string& min, const ::android::hardware::hidl_string& prl) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCDMASubscriptionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&mdn);
_hidl_args.push_back((void *)&hSid);
_hidl_args.push_back((void *)&hNid);
_hidl_args.push_back((void *)&min);
_hidl_args.push_back((void *)&prl);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCDMASubscriptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, mdn, hSid, hNid, min, prl] {
mImpl->getCDMASubscriptionResponse(info, mdn, hSid, hNid, min, prl);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCDMASubscriptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> writeSmsToRuimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, uint32_t index) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::writeSmsToRuimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&index);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "writeSmsToRuimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, index] {
mImpl->writeSmsToRuimResponse(info, index);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "writeSmsToRuimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> deleteSmsOnRuimResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::deleteSmsOnRuimResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "deleteSmsOnRuimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->deleteSmsOnRuimResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "deleteSmsOnRuimResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getDeviceIdentityResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& imei, const ::android::hardware::hidl_string& imeisv, const ::android::hardware::hidl_string& esn, const ::android::hardware::hidl_string& meid) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getDeviceIdentityResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&imei);
_hidl_args.push_back((void *)&imeisv);
_hidl_args.push_back((void *)&esn);
_hidl_args.push_back((void *)&meid);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getDeviceIdentityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, imei, imeisv, esn, meid] {
mImpl->getDeviceIdentityResponse(info, imei, imeisv, esn, meid);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getDeviceIdentityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> exitEmergencyCallbackModeResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::exitEmergencyCallbackModeResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "exitEmergencyCallbackModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->exitEmergencyCallbackModeResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "exitEmergencyCallbackModeResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getSmscAddressResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& smsc) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getSmscAddressResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&smsc);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getSmscAddressResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, smsc] {
mImpl->getSmscAddressResponse(info, smsc);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getSmscAddressResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setSmscAddressResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setSmscAddressResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setSmscAddressResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setSmscAddressResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setSmscAddressResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> reportSmsMemoryStatusResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::reportSmsMemoryStatusResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "reportSmsMemoryStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->reportSmsMemoryStatusResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "reportSmsMemoryStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> reportStkServiceIsRunningResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::reportStkServiceIsRunningResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "reportStkServiceIsRunningResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->reportStkServiceIsRunningResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "reportStkServiceIsRunningResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCdmaSubscriptionSourceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::CdmaSubscriptionSource source) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCdmaSubscriptionSourceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&source);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaSubscriptionSourceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, source] {
mImpl->getCdmaSubscriptionSourceResponse(info, source);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCdmaSubscriptionSourceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> requestIsimAuthenticationResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& response) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::requestIsimAuthenticationResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&response);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "requestIsimAuthenticationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, response] {
mImpl->requestIsimAuthenticationResponse(info, response);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "requestIsimAuthenticationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> acknowledgeIncomingGsmSmsWithPduResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::acknowledgeIncomingGsmSmsWithPduResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeIncomingGsmSmsWithPduResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->acknowledgeIncomingGsmSmsWithPduResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeIncomingGsmSmsWithPduResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendEnvelopeWithStatusResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::IccIoResult& iccIo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendEnvelopeWithStatusResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&iccIo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendEnvelopeWithStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, iccIo] {
mImpl->sendEnvelopeWithStatusResponse(info, iccIo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendEnvelopeWithStatusResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getVoiceRadioTechnologyResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, ::android::hardware::radio::V1_0::RadioTechnology rat) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getVoiceRadioTechnologyResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&rat);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getVoiceRadioTechnologyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, rat] {
mImpl->getVoiceRadioTechnologyResponse(info, rat);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getVoiceRadioTechnologyResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getCellInfoListResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::CellInfo>& cellInfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getCellInfoListResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&cellInfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getCellInfoListResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, cellInfo] {
mImpl->getCellInfoListResponse(info, cellInfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getCellInfoListResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setCellInfoListRateResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCellInfoListRateResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setCellInfoListRateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCellInfoListRateResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setCellInfoListRateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setInitialAttachApnResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setInitialAttachApnResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setInitialAttachApnResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setInitialAttachApnResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setInitialAttachApnResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getImsRegistrationStateResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool isRegistered, ::android::hardware::radio::V1_0::RadioTechnologyFamily ratFamily) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getImsRegistrationStateResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&isRegistered);
_hidl_args.push_back((void *)&ratFamily);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getImsRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, isRegistered, ratFamily] {
mImpl->getImsRegistrationStateResponse(info, isRegistered, ratFamily);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getImsRegistrationStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendImsSmsResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::SendSmsResult& sms) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendImsSmsResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&sms);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendImsSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, sms] {
mImpl->sendImsSmsResponse(info, sms);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendImsSmsResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> iccTransmitApduBasicChannelResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::IccIoResult& result) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::iccTransmitApduBasicChannelResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&result);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "iccTransmitApduBasicChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, result] {
mImpl->iccTransmitApduBasicChannelResponse(info, result);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "iccTransmitApduBasicChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> iccOpenLogicalChannelResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t channelId, const ::android::hardware::hidl_vec<int8_t>& selectResponse) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::iccOpenLogicalChannelResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&channelId);
_hidl_args.push_back((void *)&selectResponse);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "iccOpenLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, channelId, selectResponse] {
mImpl->iccOpenLogicalChannelResponse(info, channelId, selectResponse);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "iccOpenLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> iccCloseLogicalChannelResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::iccCloseLogicalChannelResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "iccCloseLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->iccCloseLogicalChannelResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "iccCloseLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> iccTransmitApduLogicalChannelResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::IccIoResult& result) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::iccTransmitApduLogicalChannelResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&result);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "iccTransmitApduLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, result] {
mImpl->iccTransmitApduLogicalChannelResponse(info, result);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "iccTransmitApduLogicalChannelResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> nvReadItemResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_string& result) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::nvReadItemResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&result);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "nvReadItemResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, result] {
mImpl->nvReadItemResponse(info, result);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "nvReadItemResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> nvWriteItemResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::nvWriteItemResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "nvWriteItemResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->nvWriteItemResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "nvWriteItemResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> nvWriteCdmaPrlResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::nvWriteCdmaPrlResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "nvWriteCdmaPrlResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->nvWriteCdmaPrlResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "nvWriteCdmaPrlResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> nvResetConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::nvResetConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "nvResetConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->nvResetConfigResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "nvResetConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setUiccSubscriptionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setUiccSubscriptionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setUiccSubscriptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setUiccSubscriptionResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setUiccSubscriptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setDataAllowedResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setDataAllowedResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setDataAllowedResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setDataAllowedResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setDataAllowedResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getHardwareConfigResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::hidl_vec<::android::hardware::radio::V1_0::HardwareConfig>& config) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getHardwareConfigResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&config);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getHardwareConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, config] {
mImpl->getHardwareConfigResponse(info, config);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getHardwareConfigResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> requestIccSimAuthenticationResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::IccIoResult& result) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::requestIccSimAuthenticationResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&result);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "requestIccSimAuthenticationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, result] {
mImpl->requestIccSimAuthenticationResponse(info, result);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "requestIccSimAuthenticationResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setDataProfileResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setDataProfileResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setDataProfileResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setDataProfileResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setDataProfileResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> requestShutdownResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::requestShutdownResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "requestShutdownResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->requestShutdownResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "requestShutdownResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getRadioCapabilityResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::RadioCapability& rc) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getRadioCapabilityResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&rc);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getRadioCapabilityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, rc] {
mImpl->getRadioCapabilityResponse(info, rc);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getRadioCapabilityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setRadioCapabilityResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::RadioCapability& rc) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setRadioCapabilityResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&rc);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setRadioCapabilityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, rc] {
mImpl->setRadioCapabilityResponse(info, rc);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setRadioCapabilityResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> startLceServiceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::LceStatusInfo& statusInfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::startLceServiceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&statusInfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "startLceServiceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, statusInfo] {
mImpl->startLceServiceResponse(info, statusInfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "startLceServiceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> stopLceServiceResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::LceStatusInfo& statusInfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::stopLceServiceResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&statusInfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "stopLceServiceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, statusInfo] {
mImpl->stopLceServiceResponse(info, statusInfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "stopLceServiceResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> pullLceDataResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::LceDataInfo& lceInfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::pullLceDataResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&lceInfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "pullLceDataResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, lceInfo] {
mImpl->pullLceDataResponse(info, lceInfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "pullLceDataResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getModemActivityInfoResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_0::ActivityStatsInfo& activityInfo) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getModemActivityInfoResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&activityInfo);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getModemActivityInfoResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, activityInfo] {
mImpl->getModemActivityInfoResponse(info, activityInfo);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getModemActivityInfoResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setAllowedCarriersResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, int32_t numAllowed) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setAllowedCarriersResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&numAllowed);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setAllowedCarriersResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, numAllowed] {
mImpl->setAllowedCarriersResponse(info, numAllowed);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setAllowedCarriersResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> getAllowedCarriersResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, bool allAllowed, const ::android::hardware::radio::V1_0::CarrierRestrictions& carriers) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getAllowedCarriersResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&allAllowed);
_hidl_args.push_back((void *)&carriers);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "getAllowedCarriersResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, allAllowed, carriers] {
mImpl->getAllowedCarriersResponse(info, allAllowed, carriers);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "getAllowedCarriersResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> sendDeviceStateResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::sendDeviceStateResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "sendDeviceStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->sendDeviceStateResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "sendDeviceStateResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setIndicationFilterResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setIndicationFilterResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setIndicationFilterResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setIndicationFilterResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setIndicationFilterResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setSimCardPowerResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setSimCardPowerResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "setSimCardPowerResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setSimCardPowerResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "setSimCardPowerResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> acknowledgeRequest(int32_t serial) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::acknowledgeRequest::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&serial);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeRequest", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, serial] {
mImpl->acknowledgeRequest(serial);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.0", "IRadioResponse", "acknowledgeRequest", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
// Methods from ::android::hardware::radio::V1_1::IRadioResponse follow.
::android::hardware::Return<void> setCarrierInfoForImsiEncryptionResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setCarrierInfoForImsiEncryptionResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "setCarrierInfoForImsiEncryptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setCarrierInfoForImsiEncryptionResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "setCarrierInfoForImsiEncryptionResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> setSimCardPowerResponse_1_1(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::setSimCardPowerResponse_1_1::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "setSimCardPowerResponse_1_1", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->setSimCardPowerResponse_1_1(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "setSimCardPowerResponse_1_1", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> startNetworkScanResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::startNetworkScanResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "startNetworkScanResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->startNetworkScanResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "startNetworkScanResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> stopNetworkScanResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::stopNetworkScanResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "stopNetworkScanResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->stopNetworkScanResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "stopNetworkScanResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> startKeepaliveResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info, const ::android::hardware::radio::V1_1::KeepaliveStatus& status) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::startKeepaliveResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
_hidl_args.push_back((void *)&status);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "startKeepaliveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info, status] {
mImpl->startKeepaliveResponse(info, status);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "startKeepaliveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<void> stopKeepaliveResponse(const ::android::hardware::radio::V1_0::RadioResponseInfo& info) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::stopKeepaliveResponse::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hardware.radio", "1.1", "IRadioResponse", "stopKeepaliveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
, info] {
mImpl->stopKeepaliveResponse(info);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hardware.radio", "1.1", "IRadioResponse", "stopKeepaliveResponse", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
// Methods from ::android::hidl::base::V1_0::IBase follow.
::android::hardware::Return<void> interfaceChain(interfaceChain_cb _hidl_cb) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::interfaceChain::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "interfaceChain", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->interfaceChain([&](const auto &_hidl_out_descriptors) {
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_descriptors);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "interfaceChain", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
_hidl_cb(_hidl_out_descriptors);
});
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> debug(const ::android::hardware::hidl_handle& fd, const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& options) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::debug::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&fd);
_hidl_args.push_back((void *)&options);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "debug", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->debug(fd, options);
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "debug", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> interfaceDescriptor(interfaceDescriptor_cb _hidl_cb) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::interfaceDescriptor::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "interfaceDescriptor", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->interfaceDescriptor([&](const auto &_hidl_out_descriptor) {
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_descriptor);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "interfaceDescriptor", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
_hidl_cb(_hidl_out_descriptor);
});
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> getHashChain(getHashChain_cb _hidl_cb) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getHashChain::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "getHashChain", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->getHashChain([&](const auto &_hidl_out_hashchain) {
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_hashchain);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "getHashChain", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
_hidl_cb(_hidl_out_hashchain);
});
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> setHALInstrumentation() override {
configureInstrumentation();
return ::android::hardware::Void();
}
::android::hardware::Return<bool> linkToDeath(const ::android::sp<::android::hardware::hidl_death_recipient>& recipient, uint64_t cookie) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::linkToDeath::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&recipient);
_hidl_args.push_back((void *)&cookie);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "linkToDeath", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->linkToDeath(recipient, cookie);
bool _hidl_out_success = _hidl_return;
(void) _hidl_out_success;
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_success);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "linkToDeath", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> ping() override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::ping::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "ping", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->ping();
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "ping", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> getDebugInfo(getDebugInfo_cb _hidl_cb) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::getDebugInfo::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "getDebugInfo", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->getDebugInfo([&](const auto &_hidl_out_info) {
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_info);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "getDebugInfo", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
_hidl_cb(_hidl_out_info);
});
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
::android::hardware::Return<void> notifySyspropsChanged() override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::notifySyspropsChanged::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "notifySyspropsChanged", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = addOnewayTask([mImpl = this->mImpl
#ifdef __ANDROID_DEBUGGABLE__
, mEnableInstrumentation = this->mEnableInstrumentation, mInstrumentationCallbacks = this->mInstrumentationCallbacks
#endif // __ANDROID_DEBUGGABLE__
] {
mImpl->notifySyspropsChanged();
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "notifySyspropsChanged", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
});
return _hidl_return;
}
::android::hardware::Return<bool> unlinkToDeath(const ::android::sp<::android::hardware::hidl_death_recipient>& recipient) override {
atrace_begin(ATRACE_TAG_HAL, "HIDL::IRadioResponse::unlinkToDeath::passthrough");
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&recipient);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_ENTRY, "android.hidl.base", "1.0", "IBase", "unlinkToDeath", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
::android::hardware::Status _hidl_error = ::android::hardware::Status::ok();
auto _hidl_return = mImpl->unlinkToDeath(recipient);
bool _hidl_out_success = _hidl_return;
(void) _hidl_out_success;
atrace_end(ATRACE_TAG_HAL);
#ifdef __ANDROID_DEBUGGABLE__
if (UNLIKELY(mEnableInstrumentation)) {
std::vector<void *> _hidl_args;
_hidl_args.push_back((void *)&_hidl_out_success);
for (const auto &callback: mInstrumentationCallbacks) {
callback(InstrumentationEvent::PASSTHROUGH_EXIT, "android.hidl.base", "1.0", "IBase", "unlinkToDeath", &_hidl_args);
}
}
#endif // __ANDROID_DEBUGGABLE__
if (!_hidl_error.isOk()) return _hidl_error;
return _hidl_return;
}
private:
const ::android::sp<IRadioResponse> mImpl;
::android::hardware::details::TaskRunner mOnewayQueue;
::android::hardware::Return<void> addOnewayTask(std::function<void(void)>);
};
} // namespace V1_1
} // namespace radio
} // namespace hardware
} // namespace android
#endif // HIDL_GENERATED_ANDROID_HARDWARE_RADIO_V1_1_BSRADIORESPONSE_H