Merge "Add VTS for voice telephony apis." (89f62595) · Commits · e / os / android_hardware_interfaces

radio/1.0/vts/functional/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ cc_test {
		defaults: ["hidl_defaults"],
		srcs: ["radio_hidl_hal_test.cpp",
		"radio_response.cpp",
		"radio_hidl_hal_voice.cpp",
		"radio_hidl_hal_icc.cpp",
		"radio_hidl_hal_sms.cpp",
		"VtsHalRadioV1_0TargetTest.cpp"],

radio/1.0/vts/functional/radio_hidl_hal_utils.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		using ::android::hardware::radio::V1_0::ActivityStatsInfo;
		using ::android::hardware::radio::V1_0::AppType;
		using ::android::hardware::radio::V1_0::CardStatus;
		using ::android::hardware::radio::V1_0::CardState;
		using ::android::hardware::radio::V1_0::Call;
		using ::android::hardware::radio::V1_0::CallForwardInfo;
		using ::android::hardware::radio::V1_0::CarrierRestrictions;
		@@ -38,6 +39,7 @@ using ::android::hardware::radio::V1_0::CdmaSubscriptionSource;
		using ::android::hardware::radio::V1_0::CellInfo;
		using ::android::hardware::radio::V1_0::ClipStatus;
		using ::android::hardware::radio::V1_0::DataRegStateResult;
		using ::android::hardware::radio::V1_0::Dial;
		using ::android::hardware::radio::V1_0::GsmBroadcastSmsConfigInfo;
		using ::android::hardware::radio::V1_0::HardwareConfig;
		using ::android::hardware::radio::V1_0::IccIo;

radio/1.0/vts/functional/radio_hidl_hal_voice.cpp

0 → 100644

+476 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include<radio_hidl_hal_utils.h>

		/*
		* Test IRadio.getCurrentCalls() for the response returned.
		*/
		TEST_F(RadioHidlTest, getCurrentCalls) {
		int serial = 1;

		radio->getCurrentCalls(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::NONE
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
		}
		}

		/*
		* Test IRadio.dial() for the response returned.
		*/
		TEST_F(RadioHidlTest, dial) {
		int serial = 1;

		Dial dialInfo;
		memset(&dialInfo, 0, sizeof(dialInfo));
		dialInfo.address = hidl_string("123456789");

		radio->dial(serial, dialInfo);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.hangup() for the response returned.
		*/
		TEST_F(RadioHidlTest, hangup) {
		int serial = 1;

		radio->hangup(serial, 1);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.hangupWaitingOrBackground() for the response returned.
		*/
		TEST_F(RadioHidlTest, hangupWaitingOrBackground) {
		int serial = 1;

		radio->hangupWaitingOrBackground(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.hangupForegroundResumeBackground() for the response returned.
		*/
		TEST_F(RadioHidlTest, hangupForegroundResumeBackground) {
		int serial = 1;

		radio->hangupForegroundResumeBackground(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.switchWaitingOrHoldingAndActive() for the response returned.
		*/
		TEST_F(RadioHidlTest, switchWaitingOrHoldingAndActive) {
		int serial = 1;

		radio->switchWaitingOrHoldingAndActive(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.conference() for the response returned.
		*/
		TEST_F(RadioHidlTest, conference) {
		int serial = 1;

		radio->conference(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.rejectCall() for the response returned.
		*/
		TEST_F(RadioHidlTest, rejectCall) {
		int serial = 1;

		radio->rejectCall(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.getLastCallFailCause() for the response returned.
		*/
		TEST_F(RadioHidlTest, getLastCallFailCause) {
		int serial = 1;

		radio->getLastCallFailCause(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::NONE);
		}
		}

		/*
		* Test IRadio.sendUssd() for the response returned.
		*/
		TEST_F(RadioHidlTest, sendUssd) {
		int serial = 1;
		radio->sendUssd(serial, hidl_string("test"));
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.cancelPendingUssd() for the response returned.
		*/
		TEST_F(RadioHidlTest, cancelPendingUssd) {
		int serial = 1;

		radio->cancelPendingUssd(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.getCallForwardStatus() for the response returned.
		*/
		TEST_F(RadioHidlTest, getCallForwardStatus) {
		int serial = 1;
		CallForwardInfo callInfo;
		memset(&callInfo, 0, sizeof(callInfo));
		callInfo.number = hidl_string();

		radio->getCallForwardStatus(serial, callInfo);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.setCallForward() for the response returned.
		*/
		TEST_F(RadioHidlTest, setCallForward) {
		int serial = 1;
		CallForwardInfo callInfo;
		memset(&callInfo, 0, sizeof(callInfo));
		callInfo.number = hidl_string();

		radio->setCallForward(serial, callInfo);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.getCallWaiting() for the response returned.
		*/
		TEST_F(RadioHidlTest, getCallWaiting) {
		int serial = 1;

		radio->getCallWaiting(serial, 1);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::NONE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.setCallWaiting() for the response returned.
		*/
		TEST_F(RadioHidlTest, setCallWaiting) {
		int serial = 1;

		radio->setCallWaiting(serial, true, 1);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.acceptCall() for the response returned.
		*/
		TEST_F(RadioHidlTest, acceptCall) {
		int serial = 1;

		radio->acceptCall(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.separateConnection() for the response returned.
		*/
		TEST_F(RadioHidlTest, separateConnection) {
		int serial = 1;

		radio->separateConnection(serial, 1);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.explicitCallTransfer() for the response returned.
		*/
		TEST_F(RadioHidlTest, explicitCallTransfer) {
		int serial = 1;

		radio->explicitCallTransfer(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.sendDtmf() for the response returned.
		*/
		TEST_F(RadioHidlTest, sendDtmf) {
		int serial = 1;

		radio->sendDtmf(serial, "1");
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::NO_RESOURCES
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR);
		}
		}

		/*
		* Test IRadio.startDtmf() for the response returned.
		*/
		TEST_F(RadioHidlTest, startDtmf) {
		int serial = 1;

		radio->startDtmf(serial, "1");
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.stopDtmf() for the response returned.
		*/
		TEST_F(RadioHidlTest, stopDtmf) {
		int serial = 1;

		radio->stopDtmf(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR);
		}
		}

		/*
		* Test IRadio.setMute() for the response returned.
		*/
		TEST_F(RadioHidlTest, setMute) {
		int serial = 1;

		radio->setMute(serial, true);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::NONE);
		}
		}

		/*
		* Test IRadio.getMute() for the response returned.
		*/
		TEST_F(RadioHidlTest, getMute) {
		int serial = 1;

		radio->getMute(serial);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::NONE);
		}
		}

		/*
		* Test IRadio.sendBurstDtmf() for the response returned.
		*/
		TEST_F(RadioHidlTest, sendBurstDtmf) {
		int serial = 1;

		radio->sendBurstDtmf(serial, "1", 0, 0);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
		EXPECT_EQ(serial, radioRsp->rspInfo.serial);

		if (cardStatus.cardState == CardState::ABSENT) {
		ASSERT_TRUE(radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS
		\|\| radioRsp->rspInfo.error == RadioError::SYSTEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::MODEM_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INTERNAL_ERR
		\|\| radioRsp->rspInfo.error == RadioError::INVALID_STATE);
		}
		}
		No newline at end of file

radio/1.0/vts/functional/radio_response.cpp

+72 −24

Original line number	Diff line number	Diff line
		@@ -77,11 +77,15 @@ Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(
		}

		Return<void> RadioResponse::getCurrentCallsResponse(
		const RadioResponseInfo& /info/, const ::android::hardware::hidl_vec<Call>& /calls/) {
		const RadioResponseInfo& info, const ::android::hardware::hidl_vec<Call>& /calls/) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::dialResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::dialResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -94,37 +98,51 @@ Return<void> RadioResponse::getIMSIForAppResponse(
		}

		Return<void> RadioResponse::hangupConnectionResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::conferenceResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::rejectCallResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::getLastCallFailCauseResponse(
		const RadioResponseInfo& /info/, const LastCallFailCauseInfo& /failCauseInfo/) {
		const RadioResponseInfo& info, const LastCallFailCauseInfo& /failCauseInfo/) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -154,7 +172,9 @@ Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& /*inf
		return Void();
		}

		Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -187,11 +207,15 @@ Return<void> RadioResponse::iccIOForAppResponse(
		return Void();
		}

		Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -205,21 +229,29 @@ Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& /info/) {
		}

		Return<void> RadioResponse::getCallForwardStatusResponse(
		const RadioResponseInfo& /info/, const ::android::hardware::hidl_vec<CallForwardInfo>&
		const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CallForwardInfo>&
		/callForwardInfos/) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::getCallWaitingResponse(
		const RadioResponseInfo& /info/, bool /enable/, int32_t /serviceClass/) {
		const RadioResponseInfo& info, bool /enable/, int32_t /serviceClass/) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -229,7 +261,9 @@ Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioRes
		return Void();
		}

		Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -273,12 +307,16 @@ Return<void> RadioResponse::getAvailableNetworksResponse(
		}

		Return<void> RadioResponse::startDtmfResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::stopDtmfResponse(
		const RadioResponseInfo& /info/) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -287,15 +325,21 @@ Return<void> RadioResponse::getBasebandVersionResponse(
		return Void();
		}

		Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& /info/, bool /enable/) {
		Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info, bool /enable/) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -366,7 +410,9 @@ Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
		return Void();
		}

		Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}

		@@ -425,7 +471,9 @@ Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo&
		return Void();
		}

		Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& /info/) {
		Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent.notify();
		return Void();
		}