1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "tel_ril_test.h"
16
17 #include <iostream>
18
19 #include "radio_event.h"
20 #include "securec.h"
21 #include "sim_constant.h"
22 #include "sim_data_type.h"
23 #include "sim_utils.h"
24 #include "tel_ril_manager.h"
25 #include "telephony_log_wrapper.h"
26
27 namespace OHOS {
28 namespace Telephony {
TelRilTest()29 TelRilTest::TelRilTest()
30 {
31 memberFuncMap_[DiffInterfaceId::TEST_CURRENT_CALLS] = &TelRilTest::OnRequestCallGetCurrentCallsStatusTest;
32 }
33
~TelRilTest()34 TelRilTest::~TelRilTest() {}
35
OnInitInterface()36 void TelRilTest::OnInitInterface()
37 {
38 telRilManager_ = std::make_shared<TelRilManager>();
39 telRilManager_->OnInit();
40
41 /* --------------------------------- MODEL ----------------------------- */
42 memberFuncMap_[DiffInterfaceId::TEST_GET_SIGNAL_STRENGTH] = &TelRilTest::OnRequestNetworkGetRssiTest;
43 memberFuncMap_[DiffInterfaceId::TEST_SHUT_DOWN] = &TelRilTest::OnRequestShutDownTest;
44 memberFuncMap_[DiffInterfaceId::TEST_SET_POWER_STATE] = &TelRilTest::OnRequestSetRadioStateTest;
45 memberFuncMap_[DiffInterfaceId::TEST_GET_POWER_STATE] = &TelRilTest::OnRequestGetRadioStateTest;
46 memberFuncMap_[DiffInterfaceId::TEST_GET_CELL_INFO_LIST] = &TelRilTest::OnRequestGetCellInfoListTest;
47 memberFuncMap_[DiffInterfaceId::TEST_GET_CURRENT_CELL_INFO] = &TelRilTest::OnRequestGetCurrentCellInfoTest;
48
49 /* --------------------------------- DATA ----------------------------- */
50 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_INIT_APN_INFO_TEST] = &TelRilTest::OnRequestSetInitApnInfoTest;
51 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SETUP_DATA_CALL_TEST] = &TelRilTest::OnRequestDataSetupDataCallTest;
52 memberFuncMap_[DiffInterfaceId::TEST_RILCM_DEACTIVATE_DATA_CALL_TEST] =
53 &TelRilTest::OnRequestDataDisableDataCallTest;
54 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_DATA_CALL_LIST_TEST] = &TelRilTest::OnRequestGetDataCallListTest;
55 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_LINK_BANDWIDTH_INFO] =
56 &TelRilTest::OnRequestGetLinkBandwidthInfoTest;
57 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_LINK_BANDWIDTH_REPORTING_RULE] =
58 &TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest;
59 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_DATA_PERMITTED_TEST] = &TelRilTest::OnRequestSetDataPermittedTest;
60 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_LINK_CAPABILITY] = &TelRilTest::OnRequestGetLinkCapabilityTest;
61 memberFuncMap_[DiffInterfaceId::TEST_RILCM_CLEAN_ALL_DATA_CONNECTIONS_TEST] =
62 &TelRilTest::OnRequestCleanAllConnectionsTest;
63 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SEND_URSP_DECODE_RESULT] = &TelRilTest::OnRequestSendUrspDecodeResult;
64 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SEND_UE_POLICY_SECTION_IDENTIFIER] =
65 &TelRilTest::OnRequestSendUePolicySectionIdentifier;
66 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SEND_IMS_RSD_LIST] = &TelRilTest::OnRequestSendImsRsdList;
67 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_ALLOWEDNSSAI] =
68 &TelRilTest::OnRequestGetNetworkSliceAllowedNssai;
69 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_EHPLMN] = &TelRilTest::OnRequestGetNetworkSliceEhplmn;
70 OnInitCall();
71
72 OnInitSms();
73
74 OnInitSim();
75
76 OnInitNetwork();
77 }
78
OnInitCall()79 void TelRilTest::OnInitCall()
80 {
81 /* --------------------------------- CALL ----------------------------- */
82 memberFuncMap_[DiffInterfaceId::TEST_CALL_DIAL] = &TelRilTest::OnRequestCallDialTest;
83 memberFuncMap_[DiffInterfaceId::TEST_HANDUP_CONNECT] = &TelRilTest::OnRequestCallHangupTest;
84 memberFuncMap_[DiffInterfaceId::TEST_ACCEPT_CALL] = &TelRilTest::OnRequestCallAnswerTest;
85 memberFuncMap_[DiffInterfaceId::TEST_HOLD_CALL] = &TelRilTest::OnRequestCallHoldTest;
86 memberFuncMap_[DiffInterfaceId::TEST_ACTIVE_CALL] = &TelRilTest::OnRequestCallActiveTest;
87 memberFuncMap_[DiffInterfaceId::TEST_SWAP_CALL] = &TelRilTest::OnRequestCallSwapTest;
88 memberFuncMap_[DiffInterfaceId::TEST_JOIN_CALL] = &TelRilTest::OnRequestCallJoinTest;
89 memberFuncMap_[DiffInterfaceId::TEST_SPLIT_CALL] = &TelRilTest::OnRequestSeparateConferenceTest;
90 memberFuncMap_[DiffInterfaceId::TEST_REJECT_CALL] = &TelRilTest::OnRequestRefusedCallTest;
91 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_WAIT] = &TelRilTest::OnRequestGetCallWaitTest;
92 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_WAIT] = &TelRilTest::OnRequestSetCallWaitTest;
93 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_FORWARD] = &TelRilTest::OnRequestGetCallForwardTest;
94 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_FORWARD] = &TelRilTest::OnRequestSetCallForwardTest;
95 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_DEAL_CLIP] = &TelRilTest::OnRequestGetClipTest;
96 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_CLIP] = &TelRilTest::OnRequestSetClipTest;
97 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_DEAL_CLIR] = &TelRilTest::OnRequestGetClirTest;
98 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_CLIR] = &TelRilTest::OnRequestSetClirTest;
99 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_RESTRICTION] = &TelRilTest::OnRequestGetCallRestrictionTest;
100 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_RESTRICTION] = &TelRilTest::OnRequestSetCallRestrictionTest;
101 memberFuncMap_[DiffInterfaceId::TEST_SEND_DTMF] = &TelRilTest::OnRequestSendDtmfTest;
102 memberFuncMap_[DiffInterfaceId::TEST_START_DTMF] = &TelRilTest::OnRequestStartDtmfTest;
103 memberFuncMap_[DiffInterfaceId::TEST_STOP_DTMF] = &TelRilTest::OnRequestStopDtmfTest;
104 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_PREFERENCE_MODE] = &TelRilTest::OnRequestSetCallPreferenceModeTest;
105 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_PREFERENCE_MODE] = &TelRilTest::OnRequestGetCallPreferenceModeTest;
106 memberFuncMap_[DiffInterfaceId::TEST_SET_USSD] = &TelRilTest::OnRequestSetUssdTest;
107 memberFuncMap_[DiffInterfaceId::TEST_GET_USSD] = &TelRilTest::OnRequestGetUssdTest;
108 memberFuncMap_[DiffInterfaceId::TEST_SET_MUTE] = &TelRilTest::OnRequestSetMuteTest;
109 memberFuncMap_[DiffInterfaceId::TEST_GET_MUTE] = &TelRilTest::OnRequestGetMuteTest;
110 memberFuncMap_[DiffInterfaceId::TEST_GET_XLEMA] = &TelRilTest::OnRequestGetEmergencyCallListTest;
111 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_FAIL] = &TelRilTest::OnRequestGetCallFailReasonTest;
112 memberFuncMap_[DiffInterfaceId::TEST_SET_VONR_SWITCH] = &TelRilTest::OnRequestSetVoNRSwitchTest;
113 }
114
OnInitSms()115 void TelRilTest::OnInitSms()
116 {
117 /* --------------------------------- SMS ----------------------------- */
118 memberFuncMap_[DiffInterfaceId::TEST_SEND_SMS] = &TelRilTest::OnRequestSendRilCmSmsTest;
119 memberFuncMap_[DiffInterfaceId::TEST_SEND_CDMA_SMS] = &TelRilTest::OnRequestSendRilCmCdmaSmsTest;
120 memberFuncMap_[DiffInterfaceId::TEST_STORAGE_SMS] = &TelRilTest::OnRequestStorageRilCmSmsTest;
121 memberFuncMap_[DiffInterfaceId::TEST_DELETE_SMS] = &TelRilTest::OnRequestDeleteRilCmSmsTest;
122 memberFuncMap_[DiffInterfaceId::TEST_UPDATE_SMS] = &TelRilTest::OnRequestUpdateRilCmSmsTest;
123 memberFuncMap_[DiffInterfaceId::TEST_SET_SMS_CENTER_ADDRESS] = &TelRilTest::OnRequestSetRilCmSmsCenterAddressTest;
124 memberFuncMap_[DiffInterfaceId::TEST_GET_SMS_CENTER_ADDRESS] = &TelRilTest::OnRequestGetRilCmSmsCenterAddressTest;
125 memberFuncMap_[DiffInterfaceId::TEST_SET_CB_CONFIG] = &TelRilTest::OnRequestSetRilCBConfigTest;
126 memberFuncMap_[DiffInterfaceId::TEST_SET_CDMA_CB_CONFIG] = &TelRilTest::OnRequestSetRilCdmaCBConfigTest;
127 memberFuncMap_[DiffInterfaceId::TEST_GET_CB_CONFIG] = &TelRilTest::OnRequestGetRilCBConfigTest;
128 memberFuncMap_[DiffInterfaceId::TEST_GET_CDMA_CB_CONFIG] = &TelRilTest::OnRequestGetRilCdmaCBConfigTest;
129 memberFuncMap_[DiffInterfaceId::TEST_SEND_SMS_EXPECT_MORE] = &TelRilTest::OnRequestSmsSendSmsExpectMoreTest;
130 memberFuncMap_[DiffInterfaceId::TEST_ACKNOWLEDGE_RILCM_LAST_INCOMING_GSM_SMS_TEST] =
131 &TelRilTest::OnRequestSmsAcknowledgeTest;
132 memberFuncMap_[DiffInterfaceId::TEST_ADD_CDMA_SMS] = &TelRilTest::OnRequestAddRilCmCdmaSmsTest;
133 memberFuncMap_[DiffInterfaceId::TEST_DEL_CDMA_SMS] = &TelRilTest::OnRequestDelRilCmCdmaSmsTest;
134 memberFuncMap_[DiffInterfaceId::TEST_UPDATE_CDMA_SMS] = &TelRilTest::OnRequestUpdateRilCmCdmaSmsTest;
135 }
136
OnInitSim()137 void TelRilTest::OnInitSim()
138 {
139 /*-----------------------------------SIM----------------------------------*/
140 memberFuncMap_[DiffInterfaceId::TEST_GET_SIM_CARD_STATUS] = &TelRilTest::OnRequestSimGetSimStatusTest;
141 memberFuncMap_[DiffInterfaceId::TEST_SIM_IO] = &TelRilTest::OnRequestSimIccIoTest;
142 memberFuncMap_[DiffInterfaceId::TEST_GET_SIM_SMS] = &TelRilTest::OnRequestSimSmsTest;
143 memberFuncMap_[DiffInterfaceId::TEST_GET_IMSI] = &TelRilTest::OnRequestSimGetImsiTest;
144 memberFuncMap_[DiffInterfaceId::TEST_GET_SIM_LOCK_STATUS] = &TelRilTest::OnRequestGetSimLockStatusTest;
145 memberFuncMap_[DiffInterfaceId::TEST_SET_SIM_LOCK] = &TelRilTest::OnRequestSetSimLockTest;
146 memberFuncMap_[DiffInterfaceId::TEST_GET_CHANGE_SIM_PASSWD] = &TelRilTest::OnRequestChangeSimPasswordTest;
147 memberFuncMap_[DiffInterfaceId::TEST_ENTER_SIM_PIN] = &TelRilTest::OnRequestEnterSimPinTest;
148 memberFuncMap_[DiffInterfaceId::TEST_UNLOCK_SIM_PIN] = &TelRilTest::OnRequestUnlockSimPinTest;
149 memberFuncMap_[DiffInterfaceId::TEST_ENTER_SIM_PIN2] = &TelRilTest::OnRequestEnterSimPin2Test;
150 memberFuncMap_[DiffInterfaceId::TEST_UNLOCK_SIM_PIN2] = &TelRilTest::OnRequestUnlockSimPin2Test;
151 memberFuncMap_[DiffInterfaceId::TEST_ENABLE_SIM_CARD] = &TelRilTest::OnRequestSetActiveSimTest;
152 memberFuncMap_[DiffInterfaceId::TEST_OPEN_LG_SIMIO] = &TelRilTest::OnRequestOpenLGSimIOTest;
153 memberFuncMap_[DiffInterfaceId::TEST_TRANSMIT_APDU_LOGICAL_CHANNEL] =
154 &TelRilTest::OnRequestTransmitApduLogicalChannelTest;
155 memberFuncMap_[DiffInterfaceId::TEST_TRANSMIT_APDU_BASIC_CHANNEL] =
156 &TelRilTest::OnRequestTransmitApduBasicChannelTest;
157 memberFuncMap_[DiffInterfaceId::TEST_SIM_AUTH] = &TelRilTest::OnRequestSimAuthenticationTest;
158 memberFuncMap_[DiffInterfaceId::TEST_SIM_SEND_NCFG_OPER_INFO] =
159 &TelRilTest::OnRequestSendSimMatchedOperatorInfoTest;
160 memberFuncMap_[DiffInterfaceId::TEST_CLOSE_LG_SIMIO] = &TelRilTest::OnRequestCloseLGSimIOTest;
161 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_TERMINAL_RESPONSE] =
162 &TelRilTest::OnRequestSendTerminalResponseCmdTest;
163 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_ENVELOPE] = &TelRilTest::OnRequestSendEnvelopeCmdTest;
164 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_CALL_SETUP_REQUEST_RESULT] =
165 &TelRilTest::OnRequestSendCallSetupRequestResultTest;
166 memberFuncMap_[DiffInterfaceId::TEST_GET_RADIO_PROTOCOL] = &TelRilTest::OnRequestGetRadioProtocolTest;
167 memberFuncMap_[DiffInterfaceId::TEST_SET_RADIO_PROTOCOL] = &TelRilTest::OnRequestSetRadioProtocolTest;
168 }
169
OnInitNetwork()170 void TelRilTest::OnInitNetwork()
171 {
172 /* --------------------------------- NETWORK ----------------------------- */
173 memberFuncMap_[DiffInterfaceId::TEST_OPERATOR] = &TelRilTest::OnRequestNetworkOperatorTest;
174 memberFuncMap_[DiffInterfaceId::TEST_GET_RILCM_VOICE_REGISTRATION_STATE_TEST] =
175 &TelRilTest::OnRequestNetworkVoiceRegistrationStateTest;
176 memberFuncMap_[DiffInterfaceId::TEST_GET_RILCM_DATA_REGISTRATION_STATE_TEST] =
177 &TelRilTest::OnRequestNetworkDataRegistrationStateTest;
178 memberFuncMap_[DiffInterfaceId::TEST_GET_NETWORKS_TO_USE] = &TelRilTest::OnRequestGetNetworkSearchInformationTest;
179 memberFuncMap_[DiffInterfaceId::TEST_GET_SELECTION_MOD_FOR_NETWORKS] =
180 &TelRilTest::OnRequestGetNetworkSelectionModeTest;
181 memberFuncMap_[DiffInterfaceId::TEST_SET_MODE_AUTOMATIC_NETWORKS] =
182 &TelRilTest::OnRequestSetNetworkSelectionModeTest;
183 memberFuncMap_[DiffInterfaceId::TEST_GET_PREFERRED_NETWORK_TYPE] = &TelRilTest::OnRequestGetPreferredNetworkTest;
184 memberFuncMap_[DiffInterfaceId::TEST_SET_PREFERRED_NETWORK_TYPE] = &TelRilTest::OnRequestSetPreferredNetworkTest;
185 memberFuncMap_[DiffInterfaceId::TEST_GET_IMEI] = &TelRilTest::OnRequestGetImeiTest;
186 memberFuncMap_[DiffInterfaceId::TEST_GET_IMEISV] = &TelRilTest::OnRequestGetImeiSvTest;
187 memberFuncMap_[DiffInterfaceId::TEST_GET_BASEBAND_VERSION] = &TelRilTest::OnRequestGetBasebandVersionTest;
188 memberFuncMap_[DiffInterfaceId::TEST_GET_MEID] = &TelRilTest::OnRequestGetMeidTest;
189 memberFuncMap_[DiffInterfaceId::TEST_GET_CS_REG_STATUS] = &TelRilTest::OnRequestGetCsRegStatusTest;
190 memberFuncMap_[DiffInterfaceId::TEST_GET_PS_REG_STATUS] = &TelRilTest::OnRequestGetPsRegStatusTest;
191 memberFuncMap_[DiffInterfaceId::TEST_GET_VOICE_RADIO_INFO] = &TelRilTest::OnRequestGetVoiceRadioTechnology;
192 memberFuncMap_[DiffInterfaceId::TEST_GET_PHYSICAL_CHANNEL_CONFIG] = &TelRilTest::OnRequestGetPhysicalChannelConfig;
193 memberFuncMap_[DiffInterfaceId::TEST_SET_LOCATE_UPDATES] = &TelRilTest::OnRequestSetLocateUpdatesTest;
194 memberFuncMap_[DiffInterfaceId::TEST_SET_NOTIFICATION_FILTER] = &TelRilTest::OnRequestSetNotificationFilterTest;
195 memberFuncMap_[DiffInterfaceId::TEST_SET_DEVICE_STATE] = &TelRilTest::OnRequestSetDeviceStateTest;
196 memberFuncMap_[DiffInterfaceId::TEST_GET_RRC_CONNECTION_STATE] = &TelRilTest::OnRequestGetRrcConnectionStateTest;
197 memberFuncMap_[DiffInterfaceId::TEST_GET_NR_OPTION_MODE] = &TelRilTest::OnRequestGetNrOptionModeTest;
198 memberFuncMap_[DiffInterfaceId::TEST_SET_NR_OPTION_MODE] = &TelRilTest::OnRequestSetNrOptionModeTest;
199 memberFuncMap_[DiffInterfaceId::TEST_GET_NR_SSBID_INFO] = &TelRilTest::OnRequestGetNrSsbIdTest;
200 }
201
OnInitForRegister(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)202 void TelRilTest::OnInitForRegister(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
203 {
204 TELEPHONY_LOGI("TelRilTest::OnInitForRegister -->");
205 // Register all APIs
206 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_STATE_CHANGED, nullptr);
207 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_DSDS_MODE_CHANGED, nullptr);
208 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_LINK_CAPABILITY_CHANGED, nullptr);
209 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_IMS_NETWORK_STATE_CHANGED, nullptr);
210 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_ON, nullptr);
211 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_NOT_AVAIL, nullptr);
212 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_CALL_STATUS_INFO, nullptr);
213 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_NETWORK_STATE, nullptr);
214 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_DATA_CALL_LIST_CHANGED, nullptr);
215 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_ICC_STATUS_CHANGED, nullptr);
216 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GSM_SMS, nullptr);
217 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_CDMA_SMS, nullptr);
218 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SMS_ON_SIM, nullptr);
219 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SMS_STATUS, nullptr);
220 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SIGNAL_STRENGTH_UPDATE, nullptr);
221 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_ICC_REFRESH, nullptr);
222 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_CONNECTED, nullptr);
223 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_PCODATA, nullptr);
224 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_JOIN_CALL, nullptr);
225 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SPLIT_CALL, nullptr);
226 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_CALL_WAIT, nullptr);
227 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_CALL_WAIT, nullptr);
228 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_CALL_FORWARD, nullptr);
229 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_CALL_FORWARD, nullptr);
230 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_CALL_CLIP, nullptr);
231 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_CALL_CLIP, nullptr);
232 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_CALL_RESTRICTION, nullptr);
233 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_CALL_RESTRICTION, nullptr);
234 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SEND_DTMF, nullptr);
235 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_START_DTMF, nullptr);
236 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_STOP_DTMF, nullptr);
237 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_REJECT_CALL, nullptr);
238 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_CALL_PREFERENCE_MODE, nullptr);
239 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_CALL_PREFERENCE_MODE, nullptr);
240 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_SET_USSD, nullptr);
241 telRilManager_->RegisterCoreNotify(slotId, handler, RadioEvent::RADIO_GET_USSD, nullptr);
242 }
243
OnProcessInput(int32_t slotId,int32_t what,const std::shared_ptr<AppExecFwk::EventHandler> & handler)244 void TelRilTest::OnProcessInput(int32_t slotId, int32_t what, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
245 {
246 auto itFunc = memberFuncMap_.find((DiffInterfaceId)what);
247 if (itFunc != memberFuncMap_.end()) {
248 auto memberFunc = itFunc->second;
249 if (memberFunc != nullptr) {
250 (this->*memberFunc)(slotId, handler);
251 }
252 }
253 }
254
OnRequestCallGetCurrentCallsStatusTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)255 void TelRilTest::OnRequestCallGetCurrentCallsStatusTest(
256 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
257 {
258 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CURRENT_CALLS);
259 if (event != nullptr && telRilManager_ != nullptr) {
260 event->SetOwner(handler);
261 TELEPHONY_LOGI("TelRilTest::OnRequestCallGetCurrentCallsStatusTest -->");
262 telRilManager_->GetCallList(slotId, event);
263 TELEPHONY_LOGI("OnRequestCallGetCurrentCallsStatusTest finished");
264 }
265 }
266 /************************************** SIM test func *******************************************/
OnRequestSimGetSimStatusTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)267 void TelRilTest::OnRequestSimGetSimStatusTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
268 {
269 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_GET_STATUS);
270 if (event != nullptr && telRilManager_ != nullptr) {
271 event->SetOwner(handler);
272 TELEPHONY_LOGI("TelRilTest::OnRequestSimGetSimStatusTest -->");
273 telRilManager_->GetSimStatus(slotId, event);
274 TELEPHONY_LOGI("TelRilTest::OnRequestSimGetSimStatusTest --> OnRequestSimGetSimStatusTest finished");
275 }
276 }
277
OnRequestSimIccIoTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)278 void TelRilTest::OnRequestSimIccIoTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
279 {
280 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_IO);
281 if (event != nullptr && telRilManager_ != nullptr) {
282 event->SetOwner(handler);
283 TELEPHONY_LOGI("TelRilTest::OnRequestSimIccIoTest -->");
284 SimIoRequestInfo simIoRequestInfo;
285 simIoRequestInfo.command = COMMAND;
286 simIoRequestInfo.fileId = FILEID;
287 simIoRequestInfo.p1 = 0;
288 simIoRequestInfo.p2 = 0;
289 simIoRequestInfo.p3 = P3;
290 simIoRequestInfo.data = "";
291 simIoRequestInfo.path = "3F007F105F3A";
292 simIoRequestInfo.pin2 = "";
293 telRilManager_->GetSimIO(slotId, simIoRequestInfo, event);
294 TELEPHONY_LOGI("TelRilTest::OnRequestSimIccIoTest --> OnRequestSimIccIoTest finished");
295 }
296 }
297
OnRequestSimSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)298 void TelRilTest::OnRequestSimSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
299 {
300 int32_t cardType = 0;
301 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_IO);
302 if (event == nullptr) {
303 TELEPHONY_LOGE("event is nullptr");
304 return;
305 }
306 event->SetOwner(handler);
307 std::cout << "input 0 : GSM or 1 : CDMA" << std::endl;
308 std::cin >> cardType;
309 TELEPHONY_LOGI("TelRilTest::cardType is %{public}d", cardType);
310 std::string path = cardType == 0 ? "3F007F10" : "3F007F25";
311 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(FILEID_SMS, path);
312 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event));
313
314 std::unique_ptr<IccToRilMsg> msg = std::make_unique<IccToRilMsg>(ctrlHolder);
315 if (msg == nullptr) {
316 TELEPHONY_LOGE("msg is nullptr");
317 return;
318 }
319 int64_t param = 0;
320 AppExecFwk::InnerEvent::Pointer process = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_IO, msg, param);
321 if (process == nullptr) {
322 TELEPHONY_LOGE("event is nullptr!");
323 return;
324 }
325 process->SetOwner(handler);
326
327 if (telRilManager_ != nullptr) {
328 TELEPHONY_LOGI("TelRilTest::OnRequestSimSmsTest -->");
329 SimIoRequestInfo simIoRequestInfo;
330 simIoRequestInfo.command = COMMAND;
331 simIoRequestInfo.fileId = FILEID_SMS;
332 simIoRequestInfo.p1 = 0;
333 simIoRequestInfo.p2 = 0;
334 simIoRequestInfo.p3 = P3;
335 simIoRequestInfo.data = "";
336 simIoRequestInfo.path = path;
337 simIoRequestInfo.pin2 = "";
338 telRilManager_->GetSimIO(slotId, simIoRequestInfo, process);
339 TELEPHONY_LOGI("TelRilTest::OnRequestSimSmsTest --> OnRequestSimSmsTest finished");
340 }
341 }
342
OnRequestOpenLGSimIOTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)343 void TelRilTest::OnRequestOpenLGSimIOTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
344 {
345 std::cout << "TelRilTest::OnRequestOpenLGSimIOTest begin:" << std::endl;
346 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_OPEN_LOGICAL_CHANNEL_DONE));
347 if (event == nullptr) {
348 std::cerr << "event is nullptr" << std::endl;
349 return;
350 }
351 event->SetOwner(handler);
352 if (telRilManager_ == nullptr) {
353 std::cerr << "telRilManager is nullptr" << std::endl;
354 return;
355 }
356 telRilManager_->SimOpenLogicalChannel(slotId, "apdu", 0, event);
357 std::cout << "TelRilTest::OnRequestOpenLGSimIOTest end" << std::endl;
358 }
359
OnRequestTransmitApduLogicalChannelTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)360 void TelRilTest::OnRequestTransmitApduLogicalChannelTest(int32_t slotId,
361 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
362 {
363 std::cout << "TelRilTest::OnRequestTransmitApduLogicalChannelTest begin:" << std::endl;
364 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_TRANSMIT_LOGICAL_CHANNEL_DONE));
365 if (event == nullptr) {
366 std::cerr << "event is nullptr" << std::endl;
367 return;
368 }
369 event->SetOwner(handler);
370 if (telRilManager_ == nullptr) {
371 std::cerr << "telRilManager is nullptr" << std::endl;
372 return;
373 }
374 ApduSimIORequestInfo reqInfo;
375 telRilManager_->SimTransmitApduLogicalChannel(slotId, reqInfo, event);
376 std::cout << "TelRilTest::OnRequestTransmitApduLogicalChannelTest end" << std::endl;
377 }
378
OnRequestTransmitApduBasicChannelTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)379 void TelRilTest::OnRequestTransmitApduBasicChannelTest(int32_t slotId,
380 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
381 {
382 std::cout << "TelRilTest::OnRequestTransmitApduBasicChannelTest begin:" << std::endl;
383 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_TRANSMIT_BASIC_CHANNEL_DONE));
384 if (event == nullptr) {
385 std::cerr << "event is nullptr" << std::endl;
386 return;
387 }
388 event->SetOwner(handler);
389 if (telRilManager_ == nullptr) {
390 std::cerr << "telRilManager is nullptr" << std::endl;
391 return;
392 }
393 ApduSimIORequestInfo reqInfo;
394 telRilManager_->SimTransmitApduBasicChannel(slotId, reqInfo, event);
395 std::cout << "TelRilTest::OnRequestTransmitApduBasicChannelTest end" << std::endl;
396 }
397
OnRequestSimAuthenticationTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)398 void TelRilTest::OnRequestSimAuthenticationTest(int32_t slotId,
399 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
400 {
401 std::cout << "TelRilTest::OnRequestSimAuthenticationTest begin:" << std::endl;
402 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_SIM_AUTHENTICATION_DONE));
403 if (event == nullptr) {
404 std::cerr << "event is nullptr" << std::endl;
405 return;
406 }
407 event->SetOwner(handler);
408 if (telRilManager_ == nullptr) {
409 std::cerr << "telRilManager is nullptr" << std::endl;
410 return;
411 }
412 int32_t authType;
413 std::string aid;
414 std::string authData;
415
416 std::cout << "please enter the authType:" << std::endl;
417 std::cout << "SIM_AUTH_EAP_SIM_TYPE is 128" << std::endl;
418 std::cout << "SIM_AUTH_EAP_AKA_TYPE is 129" << std::endl;
419 std::cin >> authType;
420 std::cout << "please enter the aid:" << std::endl;
421 std::cout << "USIM_AID" << std::endl;
422 std::cout << "CDMA_FAKE_AID" << std::endl;
423 std::cout << "GSM_FAKE_AID" << std::endl;
424 std::cin >> aid;
425 std::cout << "please enter the authData base64 encoded:" << std::endl;
426 std::cin >> authData;
427 SimAuthenticationRequestInfo reqInfo;
428 reqInfo.serial = authType;
429 reqInfo.aid = aid;
430 reqInfo.authData = authData;
431 int ret = telRilManager_->SimAuthentication(slotId, reqInfo, event);
432 TELEPHONY_LOGI("OnRequestSimAuthenticationTest ret = %{public}d", ret);
433 std::cout << "TelRilTest::OnRequestSimAuthenticationTest end" << std::endl;
434 }
435
OnRequestSendSimMatchedOperatorInfoTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)436 void TelRilTest::OnRequestSendSimMatchedOperatorInfoTest(int32_t slotId,
437 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
438 {
439 std::cout << "TelRilTest::OnRequestSendSimMatchedOperatorInfoTest begin:" << std::endl;
440 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_SIM_SEND_NCFG_OPER_INFO_DONE));
441 if (event == nullptr) {
442 std::cerr << "event is nullptr" << std::endl;
443 return;
444 }
445 event->SetOwner(handler);
446 if (telRilManager_ == nullptr) {
447 std::cerr << "telRilManager is nullptr" << std::endl;
448 return;
449 }
450
451 NcfgOperatorInfo reqInfo = NcfgOperatorInfo();
452 cout << "input operName:" << std::endl;
453 cin >> reqInfo.operName;
454 cout << "input operKey:" << std::endl;
455 cin >> reqInfo.operKey;
456 cout << "input state:" << std::endl;
457 cin >> reqInfo.state;
458 cout << "input reserve:" << std::endl;
459 cin >> reqInfo.reserve;
460 int32_t ret = telRilManager_->SendSimMatchedOperatorInfo(slotId, reqInfo, event);
461 TELEPHONY_LOGI("OnRequestSendSimMatchedOperatorInfoTest ret = %{public}d", ret);
462 std::cout << "TelRilTest::OnRequestSendSimMatchedOperatorInfoTest end" << std::endl;
463 }
464
OnRequestCloseLGSimIOTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)465 void TelRilTest::OnRequestCloseLGSimIOTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
466 {
467 std::cout << "TelRilTest::OnRequestCloseLGSimIOTest begin:" << std::endl;
468 auto event = AppExecFwk::InnerEvent::Get(uint32_t(CustomMessageID::MSG_CLOSE_LOGICAL_CHANNEL_DONE));
469 if (event == nullptr) {
470 std::cerr << "event is nullptr" << std::endl;
471 return;
472 }
473 event->SetOwner(handler);
474 if (telRilManager_ == nullptr) {
475 std::cerr << "telRilManager is nullptr" << std::endl;
476 return;
477 }
478 telRilManager_->SimCloseLogicalChannel(slotId, 0, event);
479 std::cout << "TelRilTest::OnRequestCloseLGSimIOTest end" << std::endl;
480 }
481
OnRequestSimGetImsiTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)482 void TelRilTest::OnRequestSimGetImsiTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
483 {
484 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_GET_IMSI);
485 if (event != nullptr && telRilManager_ != nullptr) {
486 event->SetOwner(handler);
487 TELEPHONY_LOGI("TelRilTest::OnRequestSimGetImsiTest -->");
488 telRilManager_->GetImsi(slotId, event);
489 TELEPHONY_LOGI("OnRequestSimGetImsiTest finished");
490 }
491 }
492
OnRequestGetSimLockStatusTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)493 void TelRilTest::OnRequestGetSimLockStatusTest(
494 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
495 {
496 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_GET_LOCK_STATUS);
497 if (event != nullptr && telRilManager_ != nullptr) {
498 event->SetOwner(handler);
499 std::string fac;
500
501 std::cout << "please enter the fac:";
502 std::cin >> fac;
503
504 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
505 telRilManager_->GetSimLockStatus(slotId, fac, event);
506 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
507 }
508 }
509
OnRequestSetSimLockTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)510 void TelRilTest::OnRequestSetSimLockTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
511 {
512 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_SET_LOCK);
513 if (event != nullptr && telRilManager_ != nullptr) {
514 event->SetOwner(handler);
515 std::string fac;
516 int32_t mode;
517 std::string code;
518
519 std::cout << "please enter the fac:";
520 std::cin >> fac;
521 std::cout << "please enter the mode:";
522 std::cin >> mode;
523 std::cout << "please enter the pwd:";
524 std::cin >> code;
525
526 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
527 SimLockParam simLock;
528 simLock.fac = fac;
529 simLock.mode = mode;
530 simLock.passwd = code;
531 telRilManager_->SetSimLock(slotId, simLock, event);
532 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
533 }
534 }
535
OnRequestChangeSimPasswordTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)536 void TelRilTest::OnRequestChangeSimPasswordTest(
537 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
538 {
539 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_CHANGE_PASSWD);
540 if (event != nullptr && telRilManager_ != nullptr) {
541 event->SetOwner(handler);
542 std::string fac;
543 std::string oldPassword;
544 std::string newPassword;
545 int32_t passwordLength = 4;
546
547 std::cout << "please enter the fac:";
548 std::cin >> fac;
549 std::cout << "please enter the oldPassword:";
550 std::cin >> oldPassword;
551 std::cout << "please enter the newPassword:";
552 std::cin >> newPassword;
553
554 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
555 SimPasswordParam simPass;
556 simPass.fac = fac;
557 simPass.oldPassword = oldPassword;
558 simPass.newPassword = newPassword;
559 simPass.passwordLength = passwordLength;
560 telRilManager_->ChangeSimPassword(slotId, simPass, event);
561 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
562 }
563 }
564
OnRequestEnterSimPinTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)565 void TelRilTest::OnRequestEnterSimPinTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
566 {
567 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ENTER_PIN);
568 if (event != nullptr && telRilManager_ != nullptr) {
569 event->SetOwner(handler);
570
571 std::string pin;
572 std::cout << "please enter the SIM PIN:";
573 std::cin >> pin;
574
575 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
576 telRilManager_->UnlockPin(slotId, pin, event);
577 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
578 }
579 }
580
OnRequestUnlockSimPinTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)581 void TelRilTest::OnRequestUnlockSimPinTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
582 {
583 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_UNLOCK_PIN);
584 if (event != nullptr && telRilManager_ != nullptr) {
585 event->SetOwner(handler);
586 std::string puk;
587 std::string pin;
588
589 std::cout << "please enter the SIM PUK:";
590 std::cin >> puk;
591 std::cout << "please enter the SIM PIN:";
592 std::cin >> pin;
593
594 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
595 telRilManager_->UnlockPuk(slotId, puk, pin, event);
596 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
597 }
598 }
599
OnRequestEnterSimPin2Test(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)600 void TelRilTest::OnRequestEnterSimPin2Test(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
601 {
602 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ENTER_PIN2);
603 if (event != nullptr && telRilManager_ != nullptr) {
604 event->SetOwner(handler);
605
606 std::string pin2;
607 std::cout << "please enter the SIM PIN2:";
608 std::cin >> pin2;
609
610 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
611 telRilManager_->UnlockPin2(slotId, pin2, event);
612 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
613 }
614 }
615
OnRequestUnlockSimPin2Test(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)616 void TelRilTest::OnRequestUnlockSimPin2Test(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
617 {
618 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_UNLOCK_PIN2);
619 if (event != nullptr && telRilManager_ != nullptr) {
620 event->SetOwner(handler);
621 std::string puk2;
622 std::string pin2;
623
624 std::cout << "please enter the SIM PUK:";
625 std::cin >> puk2;
626 std::cout << "please enter the SIM PIN:";
627 std::cin >> pin2;
628
629 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
630 telRilManager_->UnlockPuk2(slotId, puk2, pin2, event);
631 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
632 }
633 }
634
OnRequestSetActiveSimTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)635 void TelRilTest::OnRequestSetActiveSimTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
636 {
637 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_CARD_ENABLED);
638 if (event != nullptr && telRilManager_ != nullptr) {
639 event->SetOwner(handler);
640
641 int32_t index;
642 int32_t enable;
643 std::cout << "please enter the SIM index:";
644 std::cin >> index;
645
646 std::cout << "please enter the SIM enable:";
647 std::cin >> enable;
648
649 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
650 telRilManager_->SetActiveSim(slotId, index, enable, event);
651 TELEPHONY_LOGI("TelRilTest::%{public}s --> finished", __func__);
652 }
653 }
654
OnRequestGetRadioProtocolTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)655 void TelRilTest::OnRequestGetRadioProtocolTest(
656 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
657 {
658 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
659 if (event == nullptr || telRilManager_ == nullptr) {
660 TELEPHONY_LOGE("TelRilTest::OnRequestGetRadioProtocolTest telRilManager_ or event is nullptr");
661 return;
662 }
663 event->SetOwner(handler);
664 TELEPHONY_LOGI("TelRilTest::OnRequestGetRadioProtocolTest -->");
665 telRilManager_->GetRadioProtocol(slotId, event);
666 TELEPHONY_LOGI("TelRilTest::OnRequestGetRadioProtocolTest --> finished");
667 }
668
OnRequestSetRadioProtocolTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)669 void TelRilTest::OnRequestSetRadioProtocolTest(
670 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
671 {
672 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
673 if (event == nullptr || telRilManager_ == nullptr) {
674 TELEPHONY_LOGE("TelRilTest::OnRequestSetRadioProtocolTest telRilManager_ or event is nullptr");
675 return;
676 }
677 event->SetOwner(handler);
678
679 int32_t sessionId;
680 int32_t phase;
681 int32_t technology;
682 int32_t modemId;
683 int32_t status;
684 std::cout << "please enter the Radio Protocol sessionId:";
685 std::cin >> sessionId;
686 std::cout << "please enter the Radio Protocol phase(0-4):";
687 std::cin >> phase;
688 std::cout << "please enter the Radio Protocol technology(0-12):";
689 std::cin >> technology;
690 std::cout << "please enter the Radio Protocol modemId:";
691 std::cin >> modemId;
692 std::cout << "please enter the Radio Protocol status(0-2):";
693 std::cin >> status;
694
695 RadioProtocol protocol;
696 protocol.sessionId = sessionId;
697 protocol.phase = static_cast<RadioProtocolPhase>(phase);
698 protocol.technology = technology;
699 protocol.modemId = modemId;
700 protocol.status = static_cast<RadioProtocolStatus>(status);
701
702 TELEPHONY_LOGI("TelRilTest::OnRequestSetRadioProtocolTest -->");
703 telRilManager_->SetRadioProtocol(slotId, protocol, event);
704 TELEPHONY_LOGI("TelRilTest::OnRequestSetRadioProtocolTest --> finished");
705 }
706
OnRequestSendTerminalResponseCmdTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)707 void TelRilTest::OnRequestSendTerminalResponseCmdTest(
708 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
709 {
710 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_TERMINAL_RESPONSE);
711 if (event == nullptr || telRilManager_ == nullptr) {
712 TELEPHONY_LOGE("TelRilTest::OnRequestSendTerminalResponseCmdTest failed!!!!");
713 return;
714 }
715 event->SetOwner(handler);
716 std::string strCmd;
717 std::cout << "please enter the command string:";
718 std::cin >> strCmd;
719 TELEPHONY_LOGI("TelRilTest::OnRequestSendTerminalResponseCmdTest -->");
720 telRilManager_->SendTerminalResponseCmd(slotId, strCmd, event);
721 TELEPHONY_LOGI("TelRilTest::OnRequestSendTerminalResponseCmdTest --> finished");
722 }
723
OnRequestSendEnvelopeCmdTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)724 void TelRilTest::OnRequestSendEnvelopeCmdTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
725 {
726 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_ENVELOPE);
727 if (event == nullptr || telRilManager_ == nullptr) {
728 TELEPHONY_LOGE("TelRilTest::OnRequestSendEnvelopeCmdTest failed!!!!");
729 return;
730 }
731 event->SetOwner(handler);
732 std::string strCmd;
733 std::cout << "please enter the command string:";
734 std::cin >> strCmd;
735 TELEPHONY_LOGI("TelRilTest::OnRequestSendEnvelopeCmdTest -->");
736 telRilManager_->SendEnvelopeCmd(slotId, strCmd, event);
737 TELEPHONY_LOGI("TelRilTest::OnRequestSendEnvelopeCmdTest --> finished");
738 }
739
OnRequestSendCallSetupRequestResultTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)740 void TelRilTest::OnRequestSendCallSetupRequestResultTest(
741 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
742 {
743 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_CALL_SETUP_REQUEST_RESULT);
744 if (event == nullptr || telRilManager_ == nullptr) {
745 TELEPHONY_LOGE("TelRilTest::OnRequestSendCallSetupRequestResultTest failed!!!!");
746 return;
747 }
748 event->SetOwner(handler);
749 int32_t accept;
750 std::cout << "please enter the call setup request result:";
751 std::cin >> accept;
752 TELEPHONY_LOGI("TelRilTest::OnRequestSendCallSetupRequestResultTest -->");
753 telRilManager_->SendCallSetupRequestResult(slotId, accept, event);
754 TELEPHONY_LOGI("TelRilTest::OnRequestSendCallSetupRequestResultTest --> finished");
755 }
756
757 /************************************** SIM test func *******************************************/
758
OnRequestNetworkGetRssiTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)759 void TelRilTest::OnRequestNetworkGetRssiTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
760 {
761 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_SIGNAL_STRENGTH);
762 if (event != nullptr && telRilManager_ != nullptr) {
763 event->SetOwner(handler);
764 TELEPHONY_LOGI("TelRilTest::OnRequestNetworkGetRssiTest -->");
765 telRilManager_->GetSignalStrength(slotId, event);
766 TELEPHONY_LOGI("OnRequestNetworkGetRssiTest finished");
767 }
768 }
769
OnRequestCallDialTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)770 void TelRilTest::OnRequestCallDialTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
771 {
772 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DIAL);
773 if (event == nullptr || telRilManager_ == nullptr) {
774 TELEPHONY_LOGI("TelRilTest::OnRequestCallDialTest failed!!!!");
775 return;
776 }
777
778 std::string phoneNum;
779 int32_t clirMode; /* Calling Line Identification Restriction . From TS 27.007 V3.4.0 (2000-03) */
780 event->SetOwner(handler);
781 std::cout << "please enter the phone number:";
782 std::cin >> phoneNum;
783 clirMode = 0; // use subscription default value
784 TELEPHONY_LOGI("TelRilTest::OnRequestCallDialTest -->");
785 telRilManager_->Dial(slotId, phoneNum, clirMode, event);
786 TELEPHONY_LOGI("OnRequestCallDialTest finished");
787 }
788
OnRequestRefusedCallTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)789 void TelRilTest::OnRequestRefusedCallTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
790 {
791 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_REJECT_CALL);
792 if (event != nullptr && telRilManager_ != nullptr) {
793 event->SetOwner(handler);
794 TELEPHONY_LOGI("TelRilTest::OnRequestRefusedCallTest -->");
795 telRilManager_->Reject(slotId, event);
796 TELEPHONY_LOGI("OnRequestRefusedCallTest finished");
797 }
798 }
799
OnRequestGetCallWaitTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)800 void TelRilTest::OnRequestGetCallWaitTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
801 {
802 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_WAIT);
803 if (event != nullptr && telRilManager_ != nullptr) {
804 event->SetOwner(handler);
805 TELEPHONY_LOGI("TelRilTest::OnRequestGetCallWaitTest -->");
806 telRilManager_->GetCallWaiting(slotId, event);
807 TELEPHONY_LOGI("OnRequestGetCallWaitTest finished");
808 }
809 }
810
OnRequestSetCallWaitTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)811 void TelRilTest::OnRequestSetCallWaitTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
812 {
813 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CALL_WAIT);
814 if (event == nullptr || telRilManager_ == nullptr) {
815 return;
816 }
817
818 event->SetOwner(handler);
819 int32_t operating;
820 TELEPHONY_LOGI("TelRilTest::OnRequestSetCallWaitTest -->");
821 std::cout << "Please input set value[0:disable 1:enable]: " << endl;
822 std::cin >> operating;
823
824 telRilManager_->SetCallWaiting(slotId, operating, event);
825 TELEPHONY_LOGI("OnRequestSetCallWaitTest finished");
826 }
827
OnRequestCallHangupTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)828 void TelRilTest::OnRequestCallHangupTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
829 {
830 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_HANGUP_CONNECT);
831 if (event != nullptr && telRilManager_ != nullptr) {
832 event->SetOwner(handler);
833 TELEPHONY_LOGI("TelRilTest::OnRequestCallHangupTest -->");
834 telRilManager_->Hangup(slotId, static_cast<int32_t>(event->GetInnerEventId()), event);
835 TELEPHONY_LOGI("OnRequestCallHangupTest finished");
836 }
837 }
838
OnRequestCallAnswerTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)839 void TelRilTest::OnRequestCallAnswerTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
840 {
841 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ACCEPT_CALL);
842 if (event != nullptr && telRilManager_ != nullptr) {
843 event->SetOwner(handler);
844 TELEPHONY_LOGI("TelRilTest::OnRequestCallAnswerTest -->");
845 telRilManager_->Answer(slotId, event);
846 TELEPHONY_LOGI("OnRequestCallAnswerTest finished");
847 }
848 }
849
OnRequestCallHoldTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)850 void TelRilTest::OnRequestCallHoldTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
851 {
852 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_HOLD_CALL);
853 if (event != nullptr && telRilManager_ != nullptr) {
854 event->SetOwner(handler);
855 TELEPHONY_LOGI("TelRilTest::OnRequestCallHoldTest -->");
856 telRilManager_->HoldCall(slotId, event);
857 TELEPHONY_LOGI("OnRequestCallHoldTest finished");
858 }
859 }
860
OnRequestCallActiveTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)861 void TelRilTest::OnRequestCallActiveTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
862 {
863 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ACTIVE_CALL);
864 if (event != nullptr && telRilManager_ != nullptr) {
865 event->SetOwner(handler);
866 TELEPHONY_LOGI("TelRilTest::OnRequestCallActiveTest -->");
867 telRilManager_->UnHoldCall(slotId, event);
868 TELEPHONY_LOGI("OnRequestCallActiveTest finished");
869 }
870 }
871
OnRequestCallSwapTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)872 void TelRilTest::OnRequestCallSwapTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
873 {
874 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SWAP_CALL);
875 if (event != nullptr && telRilManager_ != nullptr) {
876 event->SetOwner(handler);
877 TELEPHONY_LOGI("TelRilTest::OnRequestCallSwapTest -->");
878 telRilManager_->SwitchCall(slotId, event);
879 TELEPHONY_LOGI("OnRequestCallSwapTest finished");
880 }
881 }
882
OnRequestNetworkVoiceRegistrationStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)883 void TelRilTest::OnRequestNetworkVoiceRegistrationStateTest(
884 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
885 {
886 auto event = AppExecFwk::InnerEvent::Get(TYPE);
887 if (event != nullptr && telRilManager_ != nullptr) {
888 event->SetOwner(handler);
889 TELEPHONY_LOGI("TelRilTest::OnRequestNetworkVoiceRegistrationStateTest -->");
890 telRilManager_->GetCsRegStatus(slotId, event);
891 TELEPHONY_LOGI("OnRequestNetworkVoiceRegistrationStateTest finished");
892 }
893 }
894
OnRequestNetworkDataRegistrationStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)895 void TelRilTest::OnRequestNetworkDataRegistrationStateTest(
896 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
897 {
898 auto event = AppExecFwk::InnerEvent::Get(MAXCONNSTIME);
899 if (event != nullptr && telRilManager_ != nullptr) {
900 event->SetOwner(handler);
901 TELEPHONY_LOGI("TelRilTest::OnRequestNetworkDataRegistrationStateTest -->");
902 telRilManager_->GetPsRegStatus(slotId, event);
903 TELEPHONY_LOGI("OnRequestNetworkDataRegistrationStateTest finished");
904 }
905 }
906
OnRequestNetworkOperatorTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)907 void TelRilTest::OnRequestNetworkOperatorTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
908 {
909 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_OPERATOR);
910 if (event != nullptr && telRilManager_ != nullptr) {
911 event->SetOwner(handler);
912 TELEPHONY_LOGI("TelRilTest::OnRequestNetworkOperatorTest -->");
913 telRilManager_->GetOperatorInfo(slotId, event);
914 TELEPHONY_LOGI("TelRilTest::OnRequestNetworkOperatorTest --> OnRequestNetworkOperatorTest finished");
915 }
916 }
917
OnRequestSendRilCmSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)918 void TelRilTest::OnRequestSendRilCmSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
919 {
920 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS);
921 if (event != nullptr && telRilManager_ != nullptr) {
922 event->SetOwner(handler);
923 TELEPHONY_LOGI("TelRilTest::OnRequestSendRilCmSmsTest -->");
924 telRilManager_->SendGsmSms(slotId, "smscPdu", "pdu", event);
925 TELEPHONY_LOGI("TelRilTest::OnRequestSendRilCmSmsTest --> OnRequestSendRilCmSmsTest finished");
926 }
927 }
928
OnRequestSendRilCmCdmaSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)929 void TelRilTest::OnRequestSendRilCmCdmaSmsTest(
930 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
931 {
932 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_CDMA_SMS);
933 CdmaSmsMessageInfo msg = {};
934 msg.serviceId = 1;
935 if (event != nullptr && telRilManager_ != nullptr) {
936 event->SetOwner(handler);
937 TELEPHONY_LOGI("TelRilTest::OnRequestSendRilCmCdmaSmsTest -->");
938 telRilManager_->SendCdmaSms(slotId, "pdu", event);
939 TELEPHONY_LOGI("TelRilTest::OnRequestSendRilCmCdmaSmsTest --> OnRequestSendRilCmCdmaSmsTest finished");
940 }
941 }
942
OnRequestStorageRilCmSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)943 void TelRilTest::OnRequestStorageRilCmSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
944 {
945 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STORAGE_SMS);
946 int32_t status;
947 std::cout << "Please input status:" << std::endl;
948 std::cin >> status;
949 std::cout << "Please input smsc:" << std::endl;
950 string smsc;
951 std::cin >> smsc;
952 std::cout << "Please input pdu:" << std::endl;
953 string pdu;
954 std::cin >> pdu;
955 if (event != nullptr && telRilManager_ != nullptr) {
956 event->SetOwner(handler);
957 TELEPHONY_LOGI("TelRilTest::OnRequestStorageRilCmSmsTest -->");
958 SimMessageParam simMsg;
959 simMsg.status = status;
960 simMsg.smscPdu = smsc;
961 simMsg.pdu = pdu;
962 telRilManager_->AddSimMessage(slotId, simMsg, event);
963 TELEPHONY_LOGI("TelRilTest::OnRequestStorageRilCmSmsTest --> OnRequestStorageRilCmSmsTest finished");
964 }
965 }
966
OnRequestDeleteRilCmSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)967 void TelRilTest::OnRequestDeleteRilCmSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
968 {
969 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DELETE_SMS);
970 int32_t gsmIndex;
971
972 std::cout << "Please input gsmIndex: " << endl;
973 std::cin >> gsmIndex;
974 if (event != nullptr && telRilManager_ != nullptr) {
975 event->SetOwner(handler);
976 TELEPHONY_LOGI("TelRilTest::OnRequestDeleteRilCmSmsTest -->");
977 telRilManager_->DelSimMessage(slotId, gsmIndex, event);
978 TELEPHONY_LOGI("TelRilTest::OnRequestDeleteRilCmSmsTest --> OnRequestDeleteRilCmSmsTest finished");
979 }
980 }
981
OnRequestUpdateRilCmSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)982 void TelRilTest::OnRequestUpdateRilCmSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
983 {
984 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_UPDATE_SMS);
985 int32_t gsmIndex;
986 std::string pdu;
987
988 std::cout << "Please input gsmIndex: " << endl;
989 std::cin >> gsmIndex;
990 std::cout << "Please input pdu: " << endl;
991 std::cin >> pdu;
992 if (event != nullptr && telRilManager_ != nullptr) {
993 event->SetOwner(handler);
994 SimMessageParam simMsg = {};
995 simMsg.gsmIndex = gsmIndex;
996 simMsg.status = 0;
997 simMsg.smscPdu = "00";
998 simMsg.pdu = pdu;
999 TELEPHONY_LOGI("TelRilTest::OnRequestUpdateRilCmSmsTest -->");
1000 telRilManager_->UpdateSimMessage(slotId, simMsg, event);
1001 TELEPHONY_LOGI("TelRilTest::OnRequestUpdateRilCmSmsTest --> OnRequestUpdateRilCmSmsTest finished");
1002 }
1003 }
1004
OnRequestSetRilCmSmsCenterAddressTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1005 void TelRilTest::OnRequestSetRilCmSmsCenterAddressTest(
1006 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1007 {
1008 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_SMS_CENTER_ADDRESS);
1009 int32_t tosca;
1010 std::string address;
1011
1012 std::cout << "Please input tosca: " << endl;
1013 std::cin >> tosca;
1014 std::cout << "Please input address: " << endl;
1015 std::cin >> address;
1016 if (event != nullptr && telRilManager_ != nullptr) {
1017 event->SetOwner(handler);
1018 TELEPHONY_LOGI("TelRilTest::OnRequestSetRilCmSmsCenterAddressTest -->");
1019 telRilManager_->SetSmscAddr(slotId, tosca, address, event);
1020 TELEPHONY_LOGI("OnRequestSetRilCmSmsCenterAddressTest finished");
1021 }
1022 }
1023
OnRequestGetRilCmSmsCenterAddressTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1024 void TelRilTest::OnRequestGetRilCmSmsCenterAddressTest(
1025 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1026 {
1027 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_SMS_CENTER_ADDRESS);
1028 if (event != nullptr && telRilManager_ != nullptr) {
1029 event->SetOwner(handler);
1030 TELEPHONY_LOGI("TelRilTest::OnRequestGetRilCmSmsCenterAddressTest -->");
1031 telRilManager_->GetSmscAddr(slotId, event);
1032 TELEPHONY_LOGI("OnRequestGetRilCmSmsCenterAddressTest finished");
1033 }
1034 }
1035
OnRequestSetRilCBConfigTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1036 void TelRilTest::OnRequestSetRilCBConfigTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1037 {
1038 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CELL_BROADCAST);
1039 int32_t mode;
1040 std::string idList;
1041 std::string dcsList;
1042
1043 std::cout << "Please input mode: " << endl;
1044 std::cin >> mode;
1045 if (event != nullptr && telRilManager_ != nullptr) {
1046 event->SetOwner(handler);
1047 TELEPHONY_LOGI("TelRilTest::OnRequestSetRilCBConfigTest -->");
1048 CBConfigParam cBConfig = {};
1049 cBConfig.mode = mode;
1050 cBConfig.idList = "0,1,5,320-478,922";
1051 cBConfig.dcsList = "0-3,5";
1052 telRilManager_->SetCBConfig(slotId, cBConfig, event);
1053 TELEPHONY_LOGI("TelRilTest::OnRequestSetRilCBConfigTest --> OnRequestSetRilCBConfigTest finished");
1054 }
1055 }
1056
OnRequestSetRilCdmaCBConfigTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1057 void TelRilTest::OnRequestSetRilCdmaCBConfigTest(
1058 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1059 {
1060 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CDMA_CELL_BROADCAST);
1061 CdmaCBConfigInfoList cdmaCBConfigInfoList = {};
1062 if (event != nullptr && telRilManager_ != nullptr) {
1063 event->SetOwner(handler);
1064 TELEPHONY_LOGI("TelRilTest::OnRequestSetRilCdmaCBConfigTest -->");
1065 telRilManager_->SetCdmaCBConfig(slotId, cdmaCBConfigInfoList, event);
1066 TELEPHONY_LOGI("TelRilTest::OnRequestSetRilCdmaCBConfigTest --> OnRequestSetRilCdmaCBConfigTest finished");
1067 }
1068 }
1069
OnRequestGetRilCBConfigTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1070 void TelRilTest::OnRequestGetRilCBConfigTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1071 {
1072 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CELL_BROADCAST);
1073 if (event != nullptr && telRilManager_ != nullptr) {
1074 event->SetOwner(handler);
1075 TELEPHONY_LOGI("TelRilTest::OnRequestGetRilCBConfigTest -->");
1076 telRilManager_->GetCBConfig(slotId, event);
1077 TELEPHONY_LOGI("TelRilTest::OnRequestGetRilCBConfigTest--> OnRequestGetRilCBConfigTest finished");
1078 }
1079 }
1080
OnRequestGetRilCdmaCBConfigTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1081 void TelRilTest::OnRequestGetRilCdmaCBConfigTest(
1082 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1083 {
1084 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CDMA_CELL_BROADCAST);
1085 if (event != nullptr && telRilManager_ != nullptr) {
1086 event->SetOwner(handler);
1087 TELEPHONY_LOGI("TelRilTest::OnRequestGetRilCdmaCBConfigTest -->");
1088 telRilManager_->GetCdmaCBConfig(slotId, event);
1089 TELEPHONY_LOGI("TelRilTest::OnRequestGetRilCdmaCBConfigTest--> OnRequestGetRilCdmaCBConfigTest finished");
1090 }
1091 }
1092
OnRequestSmsSendSmsExpectMoreTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1093 void TelRilTest::OnRequestSmsSendSmsExpectMoreTest(
1094 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1095 {
1096 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_SMS_EXPECT_MORE);
1097 if (event != nullptr && telRilManager_ != nullptr) {
1098 event->SetOwner(handler);
1099 TELEPHONY_LOGI("TelRilTest::OnRequestSmsSendSmsExpectMoreTest -->");
1100 telRilManager_->SendSmsMoreMode(slotId, "smscPdu", "pdu", event);
1101 TELEPHONY_LOGI("OnRequestSmsSendSmsExpectMoreTest finished");
1102 }
1103 }
1104
OnRequestAddRilCmCdmaSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1105 void TelRilTest::OnRequestAddRilCmCdmaSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1106 {
1107 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ADD_CDMA_SMS);
1108 int32_t status;
1109 std::cout << "Please input status:" << std::endl;
1110 std::cin >> status;
1111 std::cout << "Please input pdu:" << std::endl;
1112 string pdu;
1113 std::cin >> pdu;
1114 if (event != nullptr && telRilManager_ != nullptr) {
1115 event->SetOwner(handler);
1116 TELEPHONY_LOGI("TelRilTest::OnRequestAddRilCmCdmaSmsTest -->");
1117 telRilManager_->AddCdmaSimMessage(slotId, status, pdu, event);
1118 TELEPHONY_LOGI("TelRilTest::OnRequestAddRilCmCdmaSmsTest --> OnRequestAddRilCmCdmaSmsTest finished");
1119 }
1120 }
1121
OnRequestDelRilCmCdmaSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1122 void TelRilTest::OnRequestDelRilCmCdmaSmsTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1123 {
1124 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DEL_CDMA_SMS);
1125 int32_t cdmaIndex;
1126
1127 std::cout << "Please input gsmIndex: " << endl;
1128 std::cin >> cdmaIndex;
1129 if (event != nullptr && telRilManager_ != nullptr) {
1130 event->SetOwner(handler);
1131 TELEPHONY_LOGI("TelRilTest::OnRequestDelRilCmCdmaSmsTest -->");
1132 telRilManager_->DelCdmaSimMessage(slotId, cdmaIndex, event);
1133 TELEPHONY_LOGI("TelRilTest::OnRequestDelRilCmCdmaSmsTest --> OnRequestDelRilCmCdmaSmsTest finished");
1134 }
1135 }
1136
OnRequestUpdateRilCmCdmaSmsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1137 void TelRilTest::OnRequestUpdateRilCmCdmaSmsTest(
1138 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1139 {
1140 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_UPDATE_CDMA_SMS);
1141 int32_t cdmaIndex;
1142 int32_t state;
1143 std::string pdu;
1144
1145 std::cout << "Please input gsmIndex: " << endl;
1146 std::cin >> cdmaIndex;
1147 std::cout << "Please input state: " << endl;
1148 std::cin >> state;
1149 std::cout << "Please input pdu: " << endl;
1150 std::cin >> pdu;
1151 if (event != nullptr && telRilManager_ != nullptr) {
1152 event->SetOwner(handler);
1153 CdmaSimMessageParam cdmaSimMsg = {};
1154 cdmaSimMsg.cdmaIndex = cdmaIndex;
1155 cdmaSimMsg.status = state;
1156 cdmaSimMsg.pdu = pdu;
1157 TELEPHONY_LOGI("TelRilTest::OnRequestUpdateRilCmCdmaSmsTest -->");
1158 telRilManager_->UpdateCdmaSimMessage(slotId, cdmaSimMsg, event);
1159 TELEPHONY_LOGI("TelRilTest::OnRequestUpdateRilCmCdmaSmsTest --> OnRequestUpdateRilCmCdmaSmsTest finished");
1160 }
1161 }
1162
OnRequestShutDownTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1163 void TelRilTest::OnRequestShutDownTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1164 {
1165 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SHUT_DOWN);
1166 auto event = AppExecFwk::InnerEvent::Get(eventId);
1167 if (event != nullptr && telRilManager_ != nullptr) {
1168 event->SetOwner(handler);
1169 TELEPHONY_LOGI("TelRilTest::OnRequestShutDownTest -->");
1170 telRilManager_->ShutDown(slotId, event);
1171 TELEPHONY_LOGI("TelRilTest::OnRequestShutDownTest --> OnRequestShutDownTest finished");
1172 }
1173 }
1174
OnRequestSetRadioStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1175 void TelRilTest::OnRequestSetRadioStateTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1176 {
1177 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_STATUS);
1178 if (event != nullptr && telRilManager_ != nullptr) {
1179 event->SetOwner(handler);
1180 TELEPHONY_LOGI("TelRilTest::OnRequestSetRadioStateTest -->");
1181 int32_t radioState = -1;
1182
1183 std::cout << "please enter the new radioState:";
1184 std::cin >> radioState;
1185
1186 telRilManager_->SetRadioState(slotId, radioState, 0, event);
1187 TELEPHONY_LOGI("TelRilTest::OnRequestSetRadioStateTest --> OnRequestSetRadioStateTest finished");
1188 }
1189 }
1190
OnRequestGetRadioStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1191 void TelRilTest::OnRequestGetRadioStateTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1192 {
1193 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_STATUS);
1194 if (event != nullptr && telRilManager_ != nullptr) {
1195 event->SetOwner(handler);
1196 TELEPHONY_LOGI("TelRilTest::OnRequestGetRadioStateTest -->");
1197 telRilManager_->GetRadioState(slotId, event);
1198 TELEPHONY_LOGI("TelRilTest::OnRequestGetRadioStateTest --> OnRequestGetRadioStateTest finished");
1199 }
1200 }
1201
OnRequestGetCellInfoListTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1202 void TelRilTest::OnRequestGetCellInfoListTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1203 {
1204 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_POWER);
1205 if (event != nullptr && telRilManager_ != nullptr) {
1206 event->SetOwner(handler);
1207 TELEPHONY_LOGI("TelRilTest::OnRequestGetCellInfoListTest -->");
1208 telRilManager_->GetCellInfoList(slotId, event);
1209 TELEPHONY_LOGI("TelRilTest::OnRequestGetCellInfoListTest --> OnRequestGetCellInfoListTest finished");
1210 }
1211 }
1212
OnRequestGetCurrentCellInfoTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1213 void TelRilTest::OnRequestGetCurrentCellInfoTest(
1214 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1215 {
1216 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_POWER);
1217 if (event != nullptr && telRilManager_ != nullptr) {
1218 event->SetOwner(handler);
1219 TELEPHONY_LOGI("TelRilTest::OnRequestGetCurrentCellInfoTest -->");
1220 telRilManager_->GetCurrentCellInfo(slotId, event);
1221 TELEPHONY_LOGI("TelRilTest::OnRequestGetCurrentCellInfoTest --> OnRequestGetCurrentCellInfoTest finished");
1222 }
1223 }
1224
OnRequestSmsAcknowledgeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1225 void TelRilTest::OnRequestSmsAcknowledgeTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1226 {
1227 auto event = AppExecFwk::InnerEvent::Get(MAXCONNS);
1228 if (event != nullptr && telRilManager_ != nullptr) {
1229 event->SetOwner(handler);
1230 TELEPHONY_LOGI("TelRilTest::OnRequestSmsAcknowledgeTest -->");
1231 telRilManager_->SendSmsAck(slotId, true, REASON, event);
1232 TELEPHONY_LOGI("OnRequestSmsAcknowledgeTest finished");
1233 }
1234 }
1235
OnRequestSetInitApnInfoTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1236 void TelRilTest::OnRequestSetInitApnInfoTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1237 {
1238 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_INIT_APN_INFO_TEST);
1239 auto event = AppExecFwk::InnerEvent::Get(eventId);
1240 if (event != nullptr && telRilManager_ != nullptr) {
1241 event->SetOwner(handler);
1242 TELEPHONY_LOGI("TelRilTest::OnRequestSetInitApnInfoTest -->");
1243 DataProfile dataProfile = {0, "cmnet", "IPV4V6", AUTHTYPE_1, "", "", "IPV4V6"};
1244 telRilManager_->SetInitApnInfo(slotId, dataProfile, event);
1245 TELEPHONY_LOGI("OnRequestSetInitApnInfoTest finished");
1246 }
1247 }
1248
OnRequestDataSetupDataCallTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1249 void TelRilTest::OnRequestDataSetupDataCallTest(
1250 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1251 {
1252 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SETUP_DATA_CALL_TEST);
1253 auto event = AppExecFwk::InnerEvent::Get(eventId);
1254 if (event != nullptr && telRilManager_ != nullptr) {
1255 event->SetOwner(handler);
1256 TELEPHONY_LOGI("TelRilTest::OnRequestDataSetupDataCallTest -->");
1257 DataProfile dataProfile = {0, "cmnet", "IPV4V6", AUTHTYPE_1, "", "", "IPV4V6"};
1258 ActivateDataParam activateData = {0, REASON, dataProfile, false, true};
1259 telRilManager_->ActivatePdpContext(slotId, activateData, event);
1260 TELEPHONY_LOGI("OnRequestDataSetupDataCallTest finished");
1261 }
1262 }
1263
OnRequestDataDisableDataCallTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1264 void TelRilTest::OnRequestDataDisableDataCallTest(
1265 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1266 {
1267 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_DEACTIVATE_DATA_CALL_TEST);
1268 auto event = AppExecFwk::InnerEvent::Get(eventId);
1269 if (event != nullptr && telRilManager_ != nullptr) {
1270 event->SetOwner(handler);
1271 TELEPHONY_LOGI("TelRilTest::OnRequestCallDeactivateDataCallTest -->");
1272 telRilManager_->DeactivatePdpContext(slotId, CID, REASON, event);
1273 TELEPHONY_LOGI("OnRequestDataDisableDataCallTest finished");
1274 }
1275 }
1276
OnRequestGetDataCallListTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1277 void TelRilTest::OnRequestGetDataCallListTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1278 {
1279 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_DATA_CALL_LIST_TEST);
1280 auto event = AppExecFwk::InnerEvent::Get(eventId);
1281 if (event != nullptr && telRilManager_ != nullptr) {
1282 event->SetOwner(handler);
1283 TELEPHONY_LOGI("TelRilTest::OnRequestGetDataCallListTest -->");
1284 telRilManager_->GetPdpContextList(slotId, event);
1285 TELEPHONY_LOGI("OnRequestGetDataCallListTest finished");
1286 }
1287 }
1288
OnRequestGetLinkBandwidthInfoTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1289 void TelRilTest::OnRequestGetLinkBandwidthInfoTest(
1290 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1291 {
1292 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_BANDWIDTH_INFO);
1293 auto event = AppExecFwk::InnerEvent::Get(eventId);
1294 if (event != nullptr && telRilManager_ != nullptr) {
1295 int32_t cid;
1296 cout << "Please enter the specified cid:";
1297 cin >> cid;
1298 event->SetOwner(handler);
1299 TELEPHONY_LOGI("TelRilTest::OnRequestGetLinkBandwidthInfoTest -->");
1300 telRilManager_->GetLinkBandwidthInfo(slotId, cid, event);
1301 TELEPHONY_LOGI("OnRequestGetLinkBandwidthInfoTest finished");
1302 }
1303 }
1304
OnRequestGetLinkCapabilityTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1305 void TelRilTest::OnRequestGetLinkCapabilityTest(
1306 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1307 {
1308 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_CAPABILITY);
1309 auto event = AppExecFwk::InnerEvent::Get(eventId);
1310 if (event != nullptr && telRilManager_ != nullptr) {
1311 event->SetOwner(handler);
1312 TELEPHONY_LOGI("TelRilTest::OnRequestGetLinkCapabilityTest -->");
1313 telRilManager_->GetLinkCapability(slotId, event);
1314 TELEPHONY_LOGI("OnRequestGetLinkCapabilityTest finished");
1315 }
1316 }
1317
OnRequestCleanAllConnectionsTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1318 void TelRilTest::OnRequestCleanAllConnectionsTest(
1319 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1320 {
1321 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_CLEAN_ALL_DATA_CONNECTIONS_TEST);
1322 auto event = AppExecFwk::InnerEvent::Get(eventId);
1323 if (event != nullptr && telRilManager_ != nullptr) {
1324 event->SetOwner(handler);
1325 TELEPHONY_LOGI("TelRilTest::OnRequestCleanAllConnectionsTest -->");
1326 telRilManager_->CleanAllConnections(slotId, event);
1327 TELEPHONY_LOGI("OnRequestCleanAllConnectionsTest finished");
1328 }
1329 }
1330
OnRequestSetLinkBandwidthReportingRuleTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1331 void TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest(
1332 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1333 {
1334 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_LINK_BANDWIDTH_REPORTING_RULE);
1335 auto event = AppExecFwk::InnerEvent::Get(eventId);
1336 if (event != nullptr && telRilManager_ != nullptr) {
1337 event->SetOwner(handler);
1338 TELEPHONY_LOGI("TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest -->");
1339 LinkBandwidthRule rule;
1340 rule.delayMs = BANDWIDTH_HYSTERESIS_MS;
1341 rule.rat = NETWORK_TYPE_LTE;
1342 rule.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
1343 rule.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
1344 for (uint32_t i = 0; i < sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int32_t); i++) {
1345 rule.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
1346 }
1347 for (uint32_t i = 0; i < sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int32_t); i++) {
1348 rule.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
1349 }
1350 telRilManager_->SetLinkBandwidthReportingRule(slotId, rule, event);
1351 TELEPHONY_LOGI("OnRequestSetLinkBandwidthReportingRuleTest finished");
1352 }
1353 }
1354
OnRequestSendUrspDecodeResult(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1355 void TelRilTest::OnRequestSendUrspDecodeResult(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1356 {
1357 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_URSP_DECODE_RESULT);
1358 auto event = AppExecFwk::InnerEvent::Get(eventId);
1359 if (event != nullptr && telRilManager_ != nullptr) {
1360 event->SetOwner(handler);
1361 TELEPHONY_LOGI("TelRilTest::OnRequestSendUrspDecodeResult -->");
1362 std::vector<uint8_t> buffer = {0};
1363 telRilManager_->SendUrspDecodeResult(slotId, buffer, event);
1364 TELEPHONY_LOGI("OnRequestSendUrspDecodeResult finished");
1365 }
1366 }
1367
OnRequestSendUePolicySectionIdentifier(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1368 void TelRilTest::OnRequestSendUePolicySectionIdentifier(int32_t slotId,
1369 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1370 {
1371 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_UE_POLICY_SECTION_IDENTIFIER);
1372 auto event = AppExecFwk::InnerEvent::Get(eventId);
1373 if (event != nullptr && telRilManager_ != nullptr) {
1374 event->SetOwner(handler);
1375 TELEPHONY_LOGI("TelRilTest::OnRequestSendUePolicySectionIdentifier -->");
1376 std::vector<uint8_t> buffer = {0};
1377 telRilManager_->SendUePolicySectionIdentifier(slotId, buffer, event);
1378 TELEPHONY_LOGI("OnRequestSendUePolicySectionIdentifier finished");
1379 }
1380 }
1381
OnRequestSendImsRsdList(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1382 void TelRilTest::OnRequestSendImsRsdList(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1383 {
1384 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_IMS_RSD_LIST);
1385 auto event = AppExecFwk::InnerEvent::Get(eventId);
1386 if (event != nullptr && telRilManager_ != nullptr) {
1387 event->SetOwner(handler);
1388 TELEPHONY_LOGI("TelRilTest::OnRequestSendImsRsdList -->");
1389 std::vector<uint8_t> buffer = {0};
1390 telRilManager_->SendImsRsdList(slotId, buffer, event);
1391 TELEPHONY_LOGI("OnRequestSendImsRsdList finished");
1392 }
1393 }
1394
OnRequestGetNetworkSliceAllowedNssai(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1395 void TelRilTest::OnRequestGetNetworkSliceAllowedNssai(int32_t slotId,
1396 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1397 {
1398 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_ALLOWEDNSSAI);
1399 auto event = AppExecFwk::InnerEvent::Get(eventId);
1400 if (event != nullptr && telRilManager_ != nullptr) {
1401 event->SetOwner(handler);
1402 TELEPHONY_LOGI("TelRilTest::OnRequestGetNetworkSliceAllowedNssai -->");
1403 std::vector<uint8_t> buffer = {0};
1404 telRilManager_->GetNetworkSliceAllowedNssai(slotId, buffer, event);
1405 TELEPHONY_LOGI("OnRequestGetNetworkSliceAllowedNssai finished");
1406 }
1407 }
1408
OnRequestGetNetworkSliceEhplmn(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1409 void TelRilTest::OnRequestGetNetworkSliceEhplmn(int32_t slotId,
1410 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1411 {
1412 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_EHPLMN);
1413 auto event = AppExecFwk::InnerEvent::Get(eventId);
1414 if (event != nullptr && telRilManager_ != nullptr) {
1415 event->SetOwner(handler);
1416 TELEPHONY_LOGI("TelRilTest::OnRequestGetNetworkSliceEhplmn -->");
1417 std::vector<uint8_t> buffer = {0};
1418 telRilManager_->GetNetworkSliceEhplmn(slotId, buffer, event);
1419 TELEPHONY_LOGI("OnRequestGetNetworkSliceEhplmn finished");
1420 }
1421 }
1422
OnRequestSetDataPermittedTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1423 void TelRilTest::OnRequestSetDataPermittedTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1424 {
1425 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_DATA_PERMITTED_TEST);
1426 auto event = AppExecFwk::InnerEvent::Get(eventId);
1427 if (event != nullptr && telRilManager_ != nullptr) {
1428 event->SetOwner(handler);
1429 TELEPHONY_LOGI("TelRilTest::OnRequestSetDataPermittedTest -->");
1430 telRilManager_->SetDataPermitted(slotId, true, event);
1431 TELEPHONY_LOGI("TelRilTest::OnRequestSetDataPermittedTest --> finished");
1432 }
1433 }
1434
OnRequestGetNetworkSearchInformationTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1435 void TelRilTest::OnRequestGetNetworkSearchInformationTest(
1436 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1437 {
1438 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1439 if (event != nullptr && telRilManager_ != nullptr) {
1440 event->SetOwner(handler);
1441 TELEPHONY_LOGI("TelRilTest::OnRequestGetNetworkSearchInformationTest -->");
1442 telRilManager_->GetNetworkSearchInformation(slotId, event);
1443 TELEPHONY_LOGI("TelRilTest::OnRequestGetNetworkSearchInformationTest -->finished");
1444 }
1445 }
1446
OnRequestGetNetworkSelectionModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1447 void TelRilTest::OnRequestGetNetworkSelectionModeTest(
1448 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1449 {
1450 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1451 if (event != nullptr && telRilManager_ != nullptr) {
1452 event->SetOwner(handler);
1453 TELEPHONY_LOGI("TelRilTest::OnRequestGetNetworkSelectionModeTest -->");
1454 telRilManager_->GetNetworkSelectionMode(slotId, event);
1455 TELEPHONY_LOGI("OnRequestGetNetworkSelectionModeTest finished");
1456 }
1457 }
1458
OnRequestSetNetworkSelectionModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1459 void TelRilTest::OnRequestSetNetworkSelectionModeTest(
1460 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1461 {
1462 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1463 if (event != nullptr && telRilManager_ != nullptr) {
1464 event->SetOwner(handler);
1465 TELEPHONY_LOGI("TelRilTest::OnRequestSetNetworkSelectionModeTest -->");
1466 telRilManager_->SetNetworkSelectionMode(slotId, 1, "46001", event);
1467 TELEPHONY_LOGI("OnRequestSetNetworkSelectionModeTest finished");
1468 }
1469 }
1470
OnRequestSetPreferredNetworkTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1471 void TelRilTest::OnRequestSetPreferredNetworkTest(
1472 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1473 {
1474 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1475 if (event != nullptr && telRilManager_ != nullptr) {
1476 event->SetOwner(handler);
1477 int32_t netType = 0;
1478 std::cout << "Please input netType: " << endl;
1479 std::cin >> netType;
1480 TELEPHONY_LOGI("TelRilTest::OnRequestSetPreferredNetworkTest -->");
1481 telRilManager_->SetPreferredNetwork(slotId, netType, event);
1482 TELEPHONY_LOGI("OnRequestSetPreferredNetworkTest finished");
1483 }
1484 }
1485
OnRequestGetPreferredNetworkTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1486 void TelRilTest::OnRequestGetPreferredNetworkTest(
1487 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1488 {
1489 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1490 if (event != nullptr && telRilManager_ != nullptr) {
1491 event->SetOwner(handler);
1492 TELEPHONY_LOGI("TelRilTest::OnRequestGetPreferredNetworkTest -->");
1493 telRilManager_->GetPreferredNetwork(slotId, event);
1494 TELEPHONY_LOGI("OnRequestGetPreferredNetworkTest finished");
1495 }
1496 }
1497
OnRequestGetImeiTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1498 void TelRilTest::OnRequestGetImeiTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1499 {
1500 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1501 if (event != nullptr && telRilManager_ != nullptr) {
1502 event->SetOwner(handler);
1503 TELEPHONY_LOGI("TelRilTest::OnRequestGetImeiTest -->");
1504 telRilManager_->GetImei(slotId, event);
1505 TELEPHONY_LOGI("OnRequestGetImeiTest finished");
1506 }
1507 }
1508
OnRequestGetImeiSvTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1509 void TelRilTest::OnRequestGetImeiSvTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1510 {
1511 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1512 if (event != nullptr && telRilManager_ != nullptr) {
1513 event->SetOwner(handler);
1514 TELEPHONY_LOGI("TelRilTest::OnRequestGetImeiSvTest -->");
1515 telRilManager_->GetImeiSv(slotId, event);
1516 TELEPHONY_LOGI("OnRequestGetImeiSvTest finished");
1517 }
1518 }
1519
OnRequestGetBasebandVersionTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1520 void TelRilTest::OnRequestGetBasebandVersionTest(int32_t slotId,
1521 const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1522 {
1523 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_BASEBAND_VERSION);
1524 auto event = AppExecFwk::InnerEvent::Get(eventId);
1525 if (event != nullptr && telRilManager_ != nullptr) {
1526 event->SetOwner(handler);
1527 TELEPHONY_LOGI("TelRilTest::OnRequestGetBasebandVersionTest -->");
1528 telRilManager_->GetBasebandVersion(slotId, event);
1529 TELEPHONY_LOGI("OnRequestGetBasebandVersionTest finished");
1530 }
1531 }
1532
OnRequestGetMeidTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1533 void TelRilTest::OnRequestGetMeidTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1534 {
1535 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1536 if (event != nullptr && telRilManager_ != nullptr) {
1537 event->SetOwner(handler);
1538 TELEPHONY_LOGI("TelRilTest::OnRequestGetMeidTest -->");
1539 telRilManager_->GetMeid(slotId, event);
1540 TELEPHONY_LOGI("OnRequestGetMeidTest finished");
1541 }
1542 }
1543
OnRequestGetCsRegStatusTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1544 void TelRilTest::OnRequestGetCsRegStatusTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1545 {
1546 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1547 if (event != nullptr && telRilManager_ != nullptr) {
1548 event->SetOwner(handler);
1549 TELEPHONY_LOGI("TelRilTest::OnRequestGetCsRegStatusTest -->");
1550 telRilManager_->GetCsRegStatus(slotId, event);
1551 TELEPHONY_LOGI("TelRilTest::OnRequestGetCsRegStatusTest -->finished");
1552 }
1553 }
1554
OnRequestGetPsRegStatusTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1555 void TelRilTest::OnRequestGetPsRegStatusTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1556 {
1557 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1558 if (event != nullptr && telRilManager_ != nullptr) {
1559 event->SetOwner(handler);
1560 TELEPHONY_LOGI("TelRilTest::OnRequestGetPsRegStatusTest -->");
1561 telRilManager_->GetPsRegStatus(slotId, event);
1562 TELEPHONY_LOGI("TelRilTest::OnRequestGetPsRegStatusTest -->finished");
1563 }
1564 }
1565
OnRequestGetVoiceRadioTechnology(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1566 void TelRilTest::OnRequestGetVoiceRadioTechnology(
1567 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1568 {
1569 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1570 if (event != nullptr && telRilManager_ != nullptr) {
1571 event->SetOwner(handler);
1572 TELEPHONY_LOGI("TelRilTest::OnRequestGetVoiceRadioTechnology -->");
1573 telRilManager_->GetVoiceRadioTechnology(slotId, event);
1574 TELEPHONY_LOGI("TelRilTest::OnRequestGetVoiceRadioTechnology -->finished");
1575 }
1576 }
1577
OnRequestGetPhysicalChannelConfig(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1578 void TelRilTest::OnRequestGetPhysicalChannelConfig(
1579 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1580 {
1581 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1582 if (event != nullptr && telRilManager_ != nullptr) {
1583 event->SetOwner(handler);
1584 TELEPHONY_LOGI("TelRilTest::OnRequestGetPhysicalChannelConfig -->");
1585 telRilManager_->GetPhysicalChannelConfig(slotId, event);
1586 TELEPHONY_LOGI("TelRilTest::OnRequestGetPhysicalChannelConfig -->finished");
1587 }
1588 }
1589
OnRequestSetLocateUpdatesTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1590 void TelRilTest::OnRequestSetLocateUpdatesTest(
1591 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1592 {
1593 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1594 if (event != nullptr && telRilManager_ != nullptr) {
1595 event->SetOwner(handler);
1596 const int32_t NOTIFY_STAT_ONLY = 1;
1597 const int32_t NOTIFY_STAT_LAC_CELLID = 2;
1598 int32_t notifyModeValue = REG_NOTIFY_STAT_LAC_CELLID;
1599 RegNotifyMode mode;
1600 std::cout << "Please input notifyMode(NOTIFY_STAT_ONLY: 1 / NOTIFY_STAT_LAC_CELLID: 2): " << endl;
1601 std::cin >> notifyModeValue;
1602 if (notifyModeValue == NOTIFY_STAT_ONLY) {
1603 mode = REG_NOTIFY_STAT_ONLY;
1604 } else if (notifyModeValue == NOTIFY_STAT_LAC_CELLID) {
1605 mode = REG_NOTIFY_STAT_LAC_CELLID;
1606 } else {
1607 std::cout << "Please input notifyMode invalid: " << endl;
1608 return;
1609 }
1610 TELEPHONY_LOGI("TelRilTest::OnRequestSetLocateUpdatesTest -->");
1611 telRilManager_->SetLocateUpdates(slotId, mode, event);
1612 TELEPHONY_LOGI("TelRilTest::OnRequestSetLocateUpdatesTest -->finished");
1613 }
1614 }
1615
OnRequestSetNotificationFilterTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1616 void TelRilTest::OnRequestSetNotificationFilterTest(
1617 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1618 {
1619 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1620 if (event != nullptr && telRilManager_ != nullptr) {
1621 event->SetOwner(handler);
1622 int32_t filter = 0;
1623 std::cout << "Please input filter: " << endl;
1624 std::cin >> filter;
1625 TELEPHONY_LOGI("TelRilTest::OnRequestSetNotificationFilterTest -->");
1626 telRilManager_->SetNotificationFilter(slotId, filter, event);
1627 TELEPHONY_LOGI("TelRilTest::OnRequestSetNotificationFilterTest --> finished");
1628 }
1629 }
1630
OnRequestSetDeviceStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1631 void TelRilTest::OnRequestSetDeviceStateTest(
1632 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1633 {
1634 auto event = AppExecFwk::InnerEvent::Get(TYPESBITMAP);
1635 if (event != nullptr && telRilManager_ != nullptr) {
1636 event->SetOwner(handler);
1637 int32_t deviceStateType = 0;
1638 std::cout << "Please input deviceStateType: " << endl;
1639 std::cin >> deviceStateType;
1640 bool deviceStateOn = true;
1641 std::cout << "Please input deviceStateOn: " << endl;
1642 std::cin >> deviceStateOn;
1643 TELEPHONY_LOGI("TelRilTest::OnRequestSetDeviceStateTest -->");
1644 telRilManager_->SetDeviceState(slotId, deviceStateType, deviceStateOn, event);
1645 TELEPHONY_LOGI("TelRilTest::OnRequestSetDeviceStateTest --> finished");
1646 }
1647 }
1648
OnRequestGetRrcConnectionStateTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1649 void TelRilTest::OnRequestGetRrcConnectionStateTest(
1650 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1651 {
1652 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_RRC_CONNECTION_STATE);
1653 auto event = AppExecFwk::InnerEvent::Get(eventId);
1654 if (event != nullptr && telRilManager_ != nullptr) {
1655 event->SetOwner(handler);
1656 TELEPHONY_LOGI("TelRilTest::OnRequestGetRrcConnectionStateTest -->");
1657 telRilManager_->GetRrcConnectionState(slotId, event);
1658 TELEPHONY_LOGI("TelRilTest::OnRequestGetRrcConnectionStateTest --> finished");
1659 }
1660 }
1661
OnRequestGetNrOptionModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1662 void TelRilTest::OnRequestGetNrOptionModeTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1663 {
1664 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_OPTION_MODE);
1665 auto event = AppExecFwk::InnerEvent::Get(eventId);
1666 if (event != nullptr && telRilManager_ != nullptr) {
1667 event->SetOwner(handler);
1668 TELEPHONY_LOGI("TelRilTest::OnRequestGetNrOptionModeTest -->");
1669 telRilManager_->GetNrOptionMode(slotId, event);
1670 TELEPHONY_LOGI("TelRilTest::OnRequestGetNrOptionModeTest --> finished");
1671 }
1672 }
1673
OnRequestSetNrOptionModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1674 void TelRilTest::OnRequestSetNrOptionModeTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1675 {
1676 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_NR_OPTION_MODE);
1677 auto event = AppExecFwk::InnerEvent::Get(eventId);
1678 if (event != nullptr && telRilManager_ != nullptr) {
1679 event->SetOwner(handler);
1680 TELEPHONY_LOGI("TelRilTest::OnRequestSetNrOptionModeTest -->");
1681 int32_t mode = 0;
1682 std::cout << "Please input nr mode: " << endl;
1683 std::cin >> mode;
1684 telRilManager_->SetNrOptionMode(slotId, mode, event);
1685 TELEPHONY_LOGI("TelRilTest::OnRequestSetNrOptionModeTest --> finished");
1686 }
1687 }
1688
OnRequestGetNrSsbIdTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1689 void TelRilTest::OnRequestGetNrSsbIdTest(
1690 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1691 {
1692 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_SSBID_INFO);
1693 auto event = AppExecFwk::InnerEvent::Get(eventId);
1694 if (event != nullptr && telRilManager_ != nullptr) {
1695 event->SetOwner(handler);
1696 TELEPHONY_LOGI("TelRilTest::OnRequestGetNrSsbIdTest -->");
1697 telRilManager_->GetNrSsbId(slotId, event);
1698 TELEPHONY_LOGI("TelRilTest::OnRequestGetNrSsbIdTest --> finished");
1699 }
1700 }
1701
OnRequestCallJoinTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1702 void TelRilTest::OnRequestCallJoinTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1703 {
1704 int32_t callType = 0; /* call type
1705 * 0: Voice call
1706 * 1: Video call: send one-way video, two-way voice
1707 * 2: Video call: one-way receiving video, two-way voice
1708 * 3: Video call: two-way video, two-way voice
1709 */
1710
1711 TELEPHONY_LOGI("RilUnitTest::OnRequestCallJoinTest -->");
1712 std::cout << "please enter the call type:";
1713 std::cin >> callType;
1714
1715 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_JOIN_CALL);
1716 if (event != nullptr && telRilManager_ != nullptr) {
1717 event->SetOwner(handler);
1718 TELEPHONY_LOGI("TelRilTest::OnRequestCallJoinTest -->");
1719 telRilManager_->CombineConference(slotId, callType, event);
1720 TELEPHONY_LOGI("OnRequestCallJoinTest finished");
1721 }
1722 }
1723
OnRequestSeparateConferenceTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1724 void TelRilTest::OnRequestSeparateConferenceTest(
1725 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1726 {
1727 int32_t callIndex = 0;
1728 int32_t callType = 0; /* call type
1729 * 0: Voice call
1730 * 1: Video call: send one-way video, two-way voice
1731 * 2: Video call: one-way receiving video, two-way voice
1732 * 3: Video call: two-way video, two-way voice
1733 */
1734
1735 TELEPHONY_LOGI("RilUnitTest::OnRequestSeparateConferenceTest -->");
1736
1737 std::cout << "please enter the call split number:";
1738 std::cin >> callIndex;
1739
1740 std::cout << "please enter the call type:";
1741 std::cin >> callType;
1742
1743 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SPLIT_CALL);
1744 if (event != nullptr && telRilManager_ != nullptr) {
1745 event->SetOwner(handler);
1746 TELEPHONY_LOGI("TelRilTest::OnRequestSeparateConferenceTest -->");
1747 telRilManager_->SeparateConference(slotId, callIndex, callType, event);
1748 TELEPHONY_LOGI("OnRequestSeparateConferenceTest finished");
1749 }
1750 }
1751
OnRequestGetCallForwardTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1752 void TelRilTest::OnRequestGetCallForwardTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1753 {
1754 int32_t reason = 0;
1755 std::cout << "please enter Get Call Forward reason<0-5>:";
1756 std::cin >> reason;
1757
1758 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_FORWARD);
1759 if (event != nullptr && telRilManager_ != nullptr) {
1760 event->SetOwner(handler);
1761 TELEPHONY_LOGI("TelRilTest::OnRequestGetCallForwardTest -->");
1762 telRilManager_->GetCallTransferInfo(slotId, reason, event);
1763 TELEPHONY_LOGI("OnRequestGetCallForwardTest ");
1764 }
1765 }
1766
DiffParamType(int32_t loopFlag,int32_t reasonType)1767 void DiffParamType(int32_t loopFlag, int32_t reasonType)
1768 {
1769 const int32_t MIN_TYPE = 0;
1770 const int32_t MAX_TYPE = 4;
1771
1772 while (loopFlag) {
1773 cout << "0: unconditional" << endl;
1774 cout << "1: mobile busy" << endl;
1775 cout << "2: no reply" << endl;
1776 cout << "3: not reachable" << endl;
1777 cout << "4: all call forwarding" << endl;
1778 cout << "5: all conditional call forwarding" << endl;
1779 std::cout << "please select call forward reason type: ";
1780 std::cin >> reasonType;
1781 if (reasonType < MIN_TYPE || reasonType > MAX_TYPE) {
1782 std::cout << "select error, please retry!" << endl;
1783 continue;
1784 }
1785 break;
1786 }
1787 }
1788
DiffParamMode(int32_t loopFlag,int32_t mode)1789 void DiffParamMode(int32_t loopFlag, int32_t mode)
1790 {
1791 const int32_t MIN_MODE = 0;
1792 const int32_t MAX_MODE = 4;
1793 const int32_t QUERY_STATUS = 2;
1794
1795 while (loopFlag) {
1796 cout << "0: disable" << endl;
1797 cout << "1: enable" << endl; // "2: query status"
1798 cout << "3: registration" << endl;
1799 cout << "4: erasure" << endl;
1800 std::cout << "please select call forward mode type: ";
1801 std::cin >> mode;
1802 if (mode < MIN_MODE || mode > MAX_MODE) {
1803 std::cout << "select error, please retry!" << endl;
1804 continue;
1805 }
1806 if (mode == QUERY_STATUS) {
1807 std::cout << "select error, mode 2 is query status please retry!" << endl;
1808 continue;
1809 }
1810 break;
1811 }
1812 }
1813
DiffParamClassx(int32_t loopFlag,int32_t classx)1814 void DiffParamClassx(int32_t loopFlag, int32_t classx)
1815 {
1816 const int32_t MIN_CLASSX = 1;
1817 const int32_t MAX_CLASSX = 16;
1818
1819 while (loopFlag) {
1820 cout << "1: voice" << endl;
1821 cout << "2: data" << endl;
1822 cout << "4: fax" << endl;
1823 cout << "8: short message service" << endl;
1824 cout << "16: data circuit sync" << endl;
1825 std::cout << "please select call forward class type: ";
1826 std::cin >> classx;
1827 if (classx < MIN_CLASSX || classx > MAX_CLASSX) {
1828 std::cout << "select error, please retry!" << endl;
1829 continue;
1830 }
1831 break;
1832 }
1833 }
1834
OnRequestSetCallForwardTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1835 void TelRilTest::OnRequestSetCallForwardTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1836 {
1837 int32_t mode = 0;
1838 int32_t reasonType = 0;
1839 int32_t classx = 0; /* call type
1840 * 0: Voice call
1841 * 1: Video call: send one-way video, two-way voice
1842 * 2: Video call: one-way receiving video, two-way voice
1843 * 3: Video call: two-way video, two-way voice
1844 */
1845 std::string phoneNum;
1846 int32_t loopFlag = true;
1847
1848 TELEPHONY_LOGI("RilUnitTest::OnRequestSetCallForwardTest -->");
1849 DiffParamType(loopFlag, reasonType);
1850
1851 DiffParamMode(loopFlag, mode);
1852
1853 std::cout << "please enter the phone number:";
1854 std::cin >> phoneNum;
1855
1856 DiffParamClassx(loopFlag, classx);
1857
1858 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SPLIT_CALL);
1859 if (event != nullptr && telRilManager_ != nullptr) {
1860 event->SetOwner(handler);
1861 TELEPHONY_LOGI("TelRilTest::OnRequestSetCallForwardTest -->");
1862 CallTransferParam callTransfer;
1863 callTransfer.reason = reasonType;
1864 callTransfer.mode = mode;
1865 callTransfer.number = phoneNum;
1866 callTransfer.classx = classx;
1867 telRilManager_->SetCallTransferInfo(slotId, callTransfer, event);
1868 TELEPHONY_LOGI("OnRequestSetCallForwardTest finished");
1869 }
1870 }
1871
OnRequestGetClipTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1872 void TelRilTest::OnRequestGetClipTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1873 {
1874 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_CLIP);
1875 if (event != nullptr && telRilManager_ != nullptr) {
1876 event->SetOwner(handler);
1877 TELEPHONY_LOGI("TelRilTest::OnRequestGetClipTest -->");
1878 telRilManager_->GetClip(slotId, event);
1879 TELEPHONY_LOGI("OnRequestGetClipTest finished");
1880 }
1881 }
1882
OnRequestSetClipTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1883 void TelRilTest::OnRequestSetClipTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1884 {
1885 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CALL_CLIP);
1886 if (event != nullptr && telRilManager_ != nullptr) {
1887 int32_t action;
1888 event->SetOwner(handler);
1889 TELEPHONY_LOGI("TelRilTest::OnRequestSetClipTest -->");
1890 std::cout << "please input call set clip action: ";
1891 std::cin >> action;
1892 telRilManager_->SetClip(slotId, action, event);
1893 TELEPHONY_LOGI("OnRequestSetClipTest finished");
1894 }
1895 }
1896
OnRequestGetClirTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1897 void TelRilTest::OnRequestGetClirTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1898 {
1899 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_CLIR);
1900 if (event != nullptr && telRilManager_ != nullptr) {
1901 event->SetOwner(handler);
1902 TELEPHONY_LOGI("TelRilTest::OnRequestGetClirTest -->");
1903 telRilManager_->GetClir(slotId, event);
1904 TELEPHONY_LOGI("TelRilTest::OnRequestGetClirTest --> finished");
1905 }
1906 }
1907
OnRequestSetClirTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1908 void TelRilTest::OnRequestSetClirTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1909 {
1910 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CALL_CLIR);
1911 if (event != nullptr && telRilManager_ != nullptr) {
1912 int32_t action;
1913 event->SetOwner(handler);
1914 TELEPHONY_LOGI("TelRilTest::OnRequestSetClirTest -->");
1915 std::cout << "please input call set clir action: ";
1916 std::cin >> action;
1917 telRilManager_->SetClip(slotId, action, event);
1918 TELEPHONY_LOGI("TelRilTest::OnRequestSetClirTest --> finished");
1919 }
1920 }
1921
OnRequestGetCallRestrictionTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1922 void TelRilTest::OnRequestGetCallRestrictionTest(
1923 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1924 {
1925 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_RESTRICTION);
1926 if (event != nullptr && telRilManager_ != nullptr) {
1927 event->SetOwner(handler);
1928 TELEPHONY_LOGI("TelRilTest::OnRequestGetCallRestrictionTest -->");
1929 telRilManager_->GetCallRestriction(slotId, "AI", event);
1930 TELEPHONY_LOGI("OnRequestGetCallRestrictionTest finished");
1931 }
1932 }
1933
OnRequestSetCallRestrictionTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1934 void TelRilTest::OnRequestSetCallRestrictionTest(
1935 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1936 {
1937 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CALL_RESTRICTION);
1938 if (event != nullptr && telRilManager_ != nullptr) {
1939 CallRestrictionParam restriction = {};
1940
1941 std::string fac;
1942 int32_t mode;
1943 std::string code;
1944
1945 std::cout << "please enter the fac:";
1946 std::cin >> fac;
1947 std::cout << "please enter the mode:";
1948 std::cin >> mode;
1949 std::cout << "please enter the pwd:";
1950 std::cin >> code;
1951
1952 TELEPHONY_LOGI("TelRilTest::%{public}s -->", __func__);
1953 restriction.fac = fac;
1954 restriction.mode = mode;
1955 size_t cpyLen = strlen(code.c_str()) + 1;
1956 size_t maxCpyLen = sizeof(restriction.password);
1957 if (strcpy_s(restriction.password, cpyLen > maxCpyLen ? maxCpyLen : cpyLen, code.c_str()) != EOK) {
1958 TELEPHONY_LOGE("Test stop by strcpy_s fail.");
1959 return;
1960 }
1961 event->SetOwner(handler);
1962 TELEPHONY_LOGI("TelRilTest::OnRequestSetCallRestrictionTest -->");
1963 telRilManager_->SetCallRestriction(slotId, restriction, event);
1964 TELEPHONY_LOGI("OnRequestSetCallRestrictionTest finished");
1965 }
1966 }
1967
OnRequestSendDtmfTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1968 void TelRilTest::OnRequestSendDtmfTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1969 {
1970 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SEND_DTMF);
1971 if (event != nullptr && telRilManager_ != nullptr) {
1972 event->SetOwner(handler);
1973 TELEPHONY_LOGI("OnRequestSendDtmfTest finished");
1974 }
1975 }
1976
OnRequestStartDtmfTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1977 void TelRilTest::OnRequestStartDtmfTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1978 {
1979 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_START_DTMF);
1980 if (event != nullptr && telRilManager_ != nullptr) {
1981 event->SetOwner(handler);
1982 TELEPHONY_LOGI("OnRequestStartDtmfTest finished");
1983 }
1984 }
1985
OnRequestStopDtmfTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)1986 void TelRilTest::OnRequestStopDtmfTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
1987 {
1988 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STOP_DTMF);
1989 if (event != nullptr && telRilManager_ != nullptr) {
1990 event->SetOwner(handler);
1991 TELEPHONY_LOGI("TelRilTest::OnRequestStopDtmfTest -->");
1992 TELEPHONY_LOGI("OnRequestStopDtmfTest finished");
1993 }
1994 }
1995
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)1996 void TelRilTest::DemoHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
1997 {
1998 if (event == nullptr) {
1999 TELEPHONY_LOGE("TelRilTest::DemoHandler::ProcessEvent input param event is nullptr");
2000 return;
2001 }
2002 const uint32_t eventId = event->GetInnerEventId();
2003 TELEPHONY_LOGI("eventId:%{public}d, slotId:%{public}d", eventId, this->slotId_);
2004 switch (eventId) {
2005 case uint32_t(CustomMessageID::MSG_OPEN_LOGICAL_CHANNEL_DONE): {
2006 auto result = event->GetUniqueObject<OpenLogicalChannelResponse>();
2007 if (result == nullptr) {
2008 TELEPHONY_LOGE("Open logical response nullptr");
2009 break;
2010 }
2011 TELEPHONY_LOGI("Open logical response channel:'%{public}d'", result->channelId);
2012 break;
2013 }
2014 case uint32_t(CustomMessageID::MSG_TRANSMIT_LOGICAL_CHANNEL_DONE):
2015 case uint32_t(CustomMessageID::MSG_TRANSMIT_BASIC_CHANNEL_DONE): {
2016 auto result = event->GetUniqueObject<IccIoResultInfo>();
2017 if (result == nullptr) {
2018 TELEPHONY_LOGE("TransmitSimIO response nullptr");
2019 break;
2020 }
2021 TELEPHONY_LOGI("TransmitSimIO response:'%{public}s'", result->response.c_str());
2022 break;
2023 }
2024 case uint32_t(CustomMessageID::MSG_CLOSE_LOGICAL_CHANNEL_DONE): {
2025 TELEPHONY_LOGI("close logical channel done");
2026 break;
2027 }
2028 case uint32_t(CustomMessageID::MSG_SIM_AUTHENTICATION_DONE): {
2029 break;
2030 }
2031 case uint32_t(CustomMessageID::MSG_SIM_SEND_NCFG_OPER_INFO_DONE): {
2032 break;
2033 }
2034 case uint32_t(DiffInterfaceId::TEST_GET_BASEBAND_VERSION): {
2035 OnRequestGetBasebandVersionTestResponse(event);
2036 break;
2037 }
2038 case uint32_t(DiffInterfaceId::TEST_SHUT_DOWN): {
2039 OnRequestShutDownTestResponse(event);
2040 break;
2041 }
2042 default:
2043 ProcessRecordSize(event);
2044 break;
2045 }
2046 }
2047
ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer & event)2048 void TelRilTest::DemoHandler::ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer &event)
2049 {
2050 int size = 0;
2051 std::unique_ptr<IccFromRilMsg> receiveMsg = event->GetUniqueObject<IccFromRilMsg>();
2052 if (receiveMsg == nullptr) {
2053 TELEPHONY_LOGE("receiveMsg is nullptr");
2054 return;
2055 }
2056 IccFileData *result = &(receiveMsg->fileData);
2057 std::shared_ptr<IccControllerHolder> &holder = receiveMsg->controlHolder;
2058 if (result == nullptr || holder == nullptr) {
2059 return;
2060 }
2061 TELEPHONY_LOGI(" resultData: %{public}s", result->resultData.c_str());
2062 int recordLen = 0;
2063 std::shared_ptr<unsigned char> rawData = SIMUtils::HexStringConvertToBytes(result->resultData, recordLen);
2064 if (rawData == nullptr) {
2065 return;
2066 }
2067 unsigned char *fileData = rawData.get();
2068 if (recordLen > LENGTH_OF_RECORD) {
2069 GetFileAndDataSize(fileData, holder->fileSize, size);
2070 if (holder->fileSize != 0) {
2071 holder->countFiles = size / holder->fileSize;
2072 }
2073 }
2074 TELEPHONY_LOGI("ProcessRecordSize %{public}d %{public}d %{public}d", size, holder->fileSize, holder->countFiles);
2075 }
2076
GetFileAndDataSize(const unsigned char * data,int & fileSize,int & dataSize)2077 void TelRilTest::DemoHandler::GetFileAndDataSize(const unsigned char *data, int &fileSize, int &dataSize)
2078 {
2079 uint8_t byteNum = 0xFF;
2080 uint32_t offset = 8;
2081 if (data == nullptr) {
2082 TELEPHONY_LOGE("GetFileAndDataSize null data");
2083 return;
2084 }
2085 fileSize = data[LENGTH_OF_RECORD] & byteNum;
2086 dataSize = ((data[SIZE_ONE_OF_FILE] & byteNum) << offset) + (data[SIZE_TWO_OF_FILE] & byteNum);
2087 }
2088
OnRequestShutDownTestResponse(const AppExecFwk::InnerEvent::Pointer & event)2089 void TelRilTest::DemoHandler::OnRequestShutDownTestResponse(const AppExecFwk::InnerEvent::Pointer &event)
2090 {
2091 std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
2092 if (responseInfo == nullptr) {
2093 TELEPHONY_LOGI("OnRequestShutDownTestResponse success");
2094 }
2095 TELEPHONY_LOGI("test shut down done");
2096 }
2097
OnRequestGetBasebandVersionTestResponse(const AppExecFwk::InnerEvent::Pointer & event)2098 void TelRilTest::DemoHandler::OnRequestGetBasebandVersionTestResponse(const AppExecFwk::InnerEvent::Pointer &event)
2099 {
2100 std::shared_ptr<StringParcel> basebandVersion = event->GetSharedObject<StringParcel>();
2101 if (basebandVersion != nullptr) {
2102 TELEPHONY_LOGI("test get baseband version:%{public}s", basebandVersion->data.c_str());
2103 }
2104 TELEPHONY_LOGI("test get baseband version done");
2105 }
2106
OnRequestSetCallPreferenceModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2107 void TelRilTest::OnRequestSetCallPreferenceModeTest(
2108 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2109 {
2110 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CALL_PREFERENCE_MODE);
2111 if (event != nullptr && telRilManager_ != nullptr) {
2112 int32_t mode = 0;
2113 event->SetOwner(handler);
2114 std::cout << "Please enter to set the voice call mode operation,[1-4]: ";
2115 std::cin >> mode;
2116 TELEPHONY_LOGI("TelRilTest::OnRequestSetCallPreferenceModeTest --> mode = [%{public}d]", mode);
2117 telRilManager_->SetCallPreferenceMode(slotId, mode, event);
2118 TELEPHONY_LOGI("OnRequestSetCallPreferenceModeTest finished");
2119 }
2120 }
2121
OnRequestGetCallPreferenceModeTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2122 void TelRilTest::OnRequestGetCallPreferenceModeTest(
2123 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2124 {
2125 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_PREFERENCE_MODE);
2126 if (event != nullptr && telRilManager_ != nullptr) {
2127 event->SetOwner(handler);
2128 TELEPHONY_LOGI("TelRilTest::OnRequestGetCallPreferenceModeTest -->");
2129 telRilManager_->GetCallPreferenceMode(slotId, event);
2130 TELEPHONY_LOGI("OnRequestGetCallPreferenceModeTest finished");
2131 }
2132 }
2133
OnRequestSetUssdTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2134 void TelRilTest::OnRequestSetUssdTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2135 {
2136 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_USSD);
2137 if (event != nullptr && telRilManager_ != nullptr) {
2138 std::string str;
2139 event->SetOwner(handler);
2140 std::cout << "USSD string, the maximum length is 160 characters: ";
2141 std::cin >> str;
2142 TELEPHONY_LOGI("TelRilTest::OnRequestSetUssdTest --> str = [%{public}s]", str.c_str());
2143 telRilManager_->SetUssd(slotId, str, event);
2144 TELEPHONY_LOGI("OnRequestSetUssdTest finished");
2145 }
2146 }
2147
OnRequestGetUssdTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2148 void TelRilTest::OnRequestGetUssdTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2149 {
2150 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_USSD);
2151 if (event != nullptr && telRilManager_ != nullptr) {
2152 event->SetOwner(handler);
2153 TELEPHONY_LOGI("TelRilTest::OnRequestGetUssdTest -->");
2154 telRilManager_->GetUssd(slotId, event);
2155 TELEPHONY_LOGI("OnRequestGetUssdTest finished");
2156 }
2157 }
2158
OnRequestGetCallFailReasonTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2159 void TelRilTest::OnRequestGetCallFailReasonTest(
2160 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2161 {
2162 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CALL_FAIL_REASON);
2163 if (event != nullptr && telRilManager_ != nullptr) {
2164 event->SetOwner(handler);
2165 TELEPHONY_LOGI("TelRilTest::OnRequestGetCallFailReasonTest -->");
2166 telRilManager_->GetCallFailReason(slotId, event);
2167 TELEPHONY_LOGI("OnRequestGetCallFailReasonTest finished");
2168 }
2169 }
2170
OnRequestSetMuteTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2171 void TelRilTest::OnRequestSetMuteTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2172 {
2173 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_CMUT);
2174 if (event != nullptr && telRilManager_ != nullptr) {
2175 int32_t mute;
2176 event->SetOwner(handler);
2177 TELEPHONY_LOGI("TelRilTest::OnRequestSetMuteTest -->");
2178 std::cout << "CMUT set, the maximum length is 0 or 1: ";
2179 std::cin >> mute;
2180 TELEPHONY_LOGI("TelRilTest::OnRequestSetMuteTest --> mute = [%{public}d]", mute);
2181 telRilManager_->SetMute(slotId, mute, event);
2182 TELEPHONY_LOGI("OnRequestSetMuteTest finished");
2183 }
2184 }
2185
OnRequestGetMuteTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2186 void TelRilTest::OnRequestGetMuteTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2187 {
2188 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CMUT);
2189 if (event != nullptr && telRilManager_ != nullptr) {
2190 event->SetOwner(handler);
2191 TELEPHONY_LOGI("TelRilTest::OnRequestGetMuteTest -->");
2192 telRilManager_->GetMute(slotId, event);
2193 TELEPHONY_LOGI("OnRequestGetMuteTest finished");
2194 }
2195 }
2196
OnRequestGetEmergencyCallListTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2197 void TelRilTest::OnRequestGetEmergencyCallListTest(
2198 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2199 {
2200 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_EMERGENCY_CALL_LIST);
2201 if (event != nullptr && telRilManager_ != nullptr) {
2202 event->SetOwner(handler);
2203 TELEPHONY_LOGI("TelRilTest::OnRequestGetEmergencyCallListTest -->");
2204 telRilManager_->GetEmergencyCallList(slotId, event);
2205 TELEPHONY_LOGI("OnRequestGetEmergencyCallListTest finished");
2206 }
2207 }
2208
OnRequestSetVoNRSwitchTest(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)2209 void TelRilTest::OnRequestSetVoNRSwitchTest(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
2210 {
2211 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_VONR_SWITCH_STATUS);
2212 if (event != nullptr && telRilManager_ != nullptr) {
2213 int32_t state;
2214 event->SetOwner(handler);
2215 TELEPHONY_LOGI("TelRilTest::OnRequestSetVoNRSwitchTest -->");
2216 std::cout << "Please input set value[0:disable 1:enable]: ";
2217 std::cin >> state;
2218 TELEPHONY_LOGI("TelRilTest::OnRequestSetVoNRSwitchTest --> state = [%{public}d]", state);
2219 telRilManager_->SetVoNRSwitch(slotId, state, event);
2220 TELEPHONY_LOGI("OnRequestSetVoNRSwitchTest finished");
2221 }
2222 }
2223
Promote()2224 void Promote()
2225 {
2226 cout << "########################### TEL RIL TEST ######################" << endl;
2227 cout << "usage:" << endl;
2228
2229 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SHUT_DOWN) << " --> OnRequestShutDownTest" << endl;
2230 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_POWER_STATE) << " --> OnRequestSetRadioStateTest" << endl;
2231 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_POWER_STATE) << " --> OnRequestGetRadioStateTest" << endl;
2232 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_IMEI) << "--> OnRequestGetImeiTest" << endl;
2233 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_IMEISV) << "--> OnRequestGetImeiSvTest" << endl;
2234 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_BASEBAND_VERSION) << "--> OnRequestGetBasebandVersionTest"
2235 << endl;
2236 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_MEID) << "--> OnRequestGetMeidTest" << endl;
2237 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_VOICE_RADIO_INFO) << "--> OnRequestGetVoiceRadioTechnology"
2238 << endl;
2239 cout << static_cast<int32_t>(DiffInterfaceId::TEST_EXIT) << "--> Exit" << endl << endl; // exit
2240 }
2241
SimTest()2242 void SimTest()
2243 {
2244 /*-----------------------------------------------SIM-------------------------------------*/
2245 cout << "please input a cmd num: " << endl;
2246 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SIM_CARD_STATUS) << "--> OnRequestSimGetSimStatusTest"
2247 << endl; // pass
2248 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SIM_IO) << "--> OnRequestSimIccIoTest" << endl;
2249 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SIM_SMS) << "--> OnRequestSimSmsTest" << endl;
2250 cout << static_cast<int32_t>(DiffInterfaceId::TEST_OPEN_LG_SIMIO) << "--> OnRequestOpenLGSimIOTest" << endl;
2251 cout << static_cast<int32_t>(DiffInterfaceId::TEST_TRANSMIT_APDU_LOGICAL_CHANNEL)
2252 << "--> OnRequestTransmitApduLogicalChannelTest" << endl;
2253 cout << static_cast<int32_t>(DiffInterfaceId::TEST_TRANSMIT_APDU_BASIC_CHANNEL)
2254 << "--> OnRequestTransmitApduBasicChannelTest" << endl;
2255 cout << static_cast<int32_t>(DiffInterfaceId::TEST_CLOSE_LG_SIMIO) << "--> OnRequestCloseLGSimIOTest" << endl;
2256 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SIM_AUTH) << "--> OnRequestSimAuthenticationTest" << endl;
2257 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SIM_SEND_NCFG_OPER_INFO)
2258 << "--> OnRequestSendSimMatchedOperatorInfoTest" << endl;
2259
2260 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_IMSI) << "--> OnRequestSimGetImsiTest" << endl; // pass
2261 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_ICCID) << "--> OnRequestSimGetIccIDTest" << endl; // pass
2262 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SIM_LOCK_STATUS) << "--> OnRequestGetSimLockStatusTest"
2263 << endl; // pass
2264 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_SIM_LOCK) << "--> OnRequestSetSimLockTest" << endl; // pass
2265 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CHANGE_SIM_PASSWD) << "--> OnRequestChangeSimPasswordTest"
2266 << endl; // pass
2267 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ENTER_SIM_PIN) << "--> OnRequestEnterSimPinTest" << endl; // pass
2268 cout << static_cast<int32_t>(DiffInterfaceId::TEST_UNLOCK_SIM_PIN) << "--> OnRequestUnlockSimPinTest"
2269 << endl; // pass
2270 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ENTER_SIM_PIN2) << "--> OnRequestEnterSimPin2Test"
2271 << endl; // pass
2272 cout << static_cast<int32_t>(DiffInterfaceId::TEST_UNLOCK_SIM_PIN2) << "--> OnRequestUnlockSimPin2Test"
2273 << endl; // pass
2274 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ENABLE_SIM_CARD) << "--> OnRequestSetActiveSimTest"
2275 << endl; // pass
2276
2277 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_DATA_CALL_LIST_TEST)
2278 << "--> OnRequestGetDataCallListTest" << endl; // pass
2279 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ACKNOWLEDGE_RILCM_LAST_INCOMING_GSM_SMS_TEST)
2280 << "--> OnRequestSmsAcknowledgeTest" << endl;
2281 cout << static_cast<int32_t>(DiffInterfaceId::TEST_STK_SEND_TERMINAL_RESPONSE)
2282 << "--> OnRequestSendTerminalResponseCmdTest" << endl; // pass
2283 cout << static_cast<int32_t>(DiffInterfaceId::TEST_STK_SEND_ENVELOPE)
2284 << "--> OnRequestSendEnvelopeCmdTest" << endl; // pass
2285 cout << static_cast<int32_t>(DiffInterfaceId::TEST_STK_SEND_CALL_SETUP_REQUEST_RESULT)
2286 << "--> OnRequestSendCallSetupRequestResultTest" << endl; // pass
2287 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_RADIO_PROTOCOL)
2288 << "--> OnRequestGetRadioProtocolTest" << endl;
2289 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_RADIO_PROTOCOL)
2290 << "--> OnRequestSetRadioProtocolTest" << endl;
2291 }
2292
DataTest()2293 void DataTest()
2294 {
2295 cout << "=========== Cellular Data Start =============" << endl;
2296 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_INIT_APN_INFO_TEST)
2297 << "--> OnRequestSetInitApnInfoTest" << endl;
2298 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SETUP_DATA_CALL_TEST)
2299 << "--> OnRequestDataSetupDataCallTest" << endl;
2300 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_DEACTIVATE_DATA_CALL_TEST)
2301 << "--> OnRequestDataDisableDataCallTest" << endl; // pass
2302 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_BANDWIDTH_INFO)
2303 << "--> OnRequestGetLinkBandwidthInfoTest" << endl;
2304 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_LINK_BANDWIDTH_REPORTING_RULE)
2305 << "--> OnRequestSetLinkBandwidthReportingRuleTest" << endl;
2306 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_DATA_PERMITTED_TEST)
2307 << "--> OnRequestSetDataPermittedTest" << endl;
2308 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_CAPABILITY)
2309 << "--> OnRequestGetLinkCapabilityTest" << endl;
2310 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_CLEAN_ALL_DATA_CONNECTIONS_TEST)
2311 << "--> OnRequestCleanAllConnectionsTest" << endl;
2312 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_URSP_DECODE_RESULT)
2313 << "--> OnRequestSendUrspDecodeResult" << endl;
2314 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_UE_POLICY_SECTION_IDENTIFIER)
2315 << "--> OnRequestSendUePolicySectionIdentifier" << endl;
2316 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SEND_IMS_RSD_LIST)
2317 << "--> OnRequestSendImsRsdList" << endl;
2318 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_ALLOWEDNSSAI)
2319 << "--> OnRequestGetNetworkSliceAllowedNssai" << endl;
2320 cout << static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_NETWORKSLICE_EHPLMN)
2321 << "--> OnRequestGetNetworkSliceEhplmn" << endl;
2322 cout << "=========== Cellular Data End =============" << endl;
2323 }
2324
CallTest()2325 void CallTest()
2326 {
2327 /* --------------------------------- CALL -------------------------- */
2328 cout << static_cast<int32_t>(DiffInterfaceId::TEST_CALL_DIAL) << " --> OnRequestCallDialTest" << endl;
2329 cout << static_cast<int32_t>(DiffInterfaceId::TEST_HANDUP_CONNECT) << " --> OnRequestCallHangupTest" << endl;
2330 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ACCEPT_CALL) << "--> OnRequestCallAnswerTest" << endl;
2331 cout << static_cast<int32_t>(DiffInterfaceId::TEST_CURRENT_CALLS) << "--> OnRequestCallGetCurrentCallsStatusTest"
2332 << endl;
2333 cout << static_cast<int32_t>(DiffInterfaceId::TEST_REJECT_CALL) << "--> OnRequestRefusedCallTest" << endl;
2334 cout << static_cast<int32_t>(DiffInterfaceId::TEST_JOIN_CALL) << "--> OnRequestCallJoinTest" << endl;
2335 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SPLIT_CALL) << "--> OnRequestSeparateConferenceTest" << endl;
2336 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_WAIT) << " --> OnRequestGetCallWaitTest" << endl;
2337 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_WAIT) << " --> OnRequestSetCallWaitTest" << endl;
2338 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_FORWARD) << " --> OnRequestGetCallForwardTest" << endl;
2339 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_FORWARD) << " --> OnRequestSetCallForwardTest" << endl;
2340 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_DEAL_CLIP) << " --> OnRequestGetClipTest" << endl;
2341 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_CLIP) << " --> OnRequestSetClipTest" << endl;
2342 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_DEAL_CLIR) << " --> OnRequestGetClirTest" << endl;
2343 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_CLIR) << " --> OnRequestSetClirTest" << endl;
2344 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_RESTRICTION) << " --> OnRequestGetCallRestrictionTest"
2345 << endl;
2346 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_RESTRICTION) << " --> OnRequestSetCallRestrictionTest"
2347 << endl;
2348 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SEND_DTMF) << " --> OnRequestSendDtmfTest" << endl;
2349 cout << static_cast<int32_t>(DiffInterfaceId::TEST_START_DTMF) << " --> OnRequestStartDtmfTest" << endl;
2350 cout << static_cast<int32_t>(DiffInterfaceId::TEST_STOP_DTMF) << " --> OnRequestStopDtmfTest" << endl;
2351 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CALL_PREFERENCE_MODE)
2352 << "--> OnRequestSetCallPreferenceModeTest" << endl;
2353 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_PREFERENCE_MODE)
2354 << "--> OnRequestGetCallPreferenceModeTest" << endl;
2355 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_USSD) << " --> OnRequestSetUssdTest" << endl;
2356 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_USSD) << " --> OnRequestGetUssdTest" << endl;
2357 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_MUTE) << " --> OnRequestSetMuteTest" << endl;
2358 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_MUTE) << " --> OnRequestGetMuteTest" << endl;
2359 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_XLEMA) << " --> OnRequestGetEmergencyCallListTest" << endl;
2360 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CALL_FAIL) << " --> OnRequestGetCallFailReasonTest" << endl;
2361 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_VONR_SWITCH) << " --> OnRequestSetVoNRSwitchTest" << endl;
2362 }
2363
SmsTest()2364 void SmsTest()
2365 {
2366 /* --------------------------------- SMS -------------------------- */
2367 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SEND_SMS) << "--> OnRequestSendRilCmSmsTest"
2368 << endl; // failed, Sim not inserted, radioResponseInfo->error : 2
2369 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SEND_CDMA_SMS) << "--> OnRequestSendRilCmCdmaSmsTest" << endl;
2370 cout << static_cast<int32_t>(DiffInterfaceId::TEST_STORAGE_SMS) << "--> OnRequestStorageRilCmSmsTest" << endl;
2371 cout << static_cast<int32_t>(DiffInterfaceId::TEST_DELETE_SMS) << "--> OnRequestDeleteRilCmSmsTest" << endl;
2372 cout << static_cast<int32_t>(DiffInterfaceId::TEST_UPDATE_SMS) << "--> OnRequestUpdateRilCmSmsTest" << endl;
2373 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_SMS_CENTER_ADDRESS)
2374 << "--> OnRequestSetRilCmSmsCenterAddressTest" << endl;
2375 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SMS_CENTER_ADDRESS)
2376 << "--> OnRequestGetRilCmSmsCenterAddressTest" << endl;
2377 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_CB_CONFIG) << "--> OnRequestSetRilCBConfigTest" << endl;
2378 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CB_CONFIG) << "--> OnRequestGetRilCBConfigTest" << endl;
2379 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CDMA_CB_CONFIG) << "--> OnRequestGetRilCdmaCBConfigTest"
2380 << endl;
2381 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SEND_SMS_EXPECT_MORE) << " --> OnRequestSmsSendSmsExpectMoreTest"
2382 << endl; // failed, Sim not inserted, radioResponseInfo->error : 2
2383 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_RILCM_VOICE_REGISTRATION_STATE_TEST)
2384 << "--> OnRequestNetworkVoiceRegistrationStateTest" << endl; // pass
2385 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_RILCM_DATA_REGISTRATION_STATE_TEST)
2386 << "--> OnRequestNetworkDataRegistrationStateTest" << endl; // pass
2387 cout << static_cast<int32_t>(DiffInterfaceId::TEST_ADD_CDMA_SMS) << "--> OnRequestAddRilCmCdmaSmsTest" << endl;
2388 cout << static_cast<int32_t>(DiffInterfaceId::TEST_DEL_CDMA_SMS) << "--> OnRequestDelRilCmCdmaSmsTest" << endl;
2389 cout << static_cast<int32_t>(DiffInterfaceId::TEST_UPDATE_CDMA_SMS) << "--> OnRequestUpdateRilCmCdmaSmsTest"
2390 << endl;
2391 }
2392
NetworkTest()2393 void NetworkTest()
2394 {
2395 /* --------------------------------- Network -------------------------- */
2396 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_PREFERRED_NETWORK_TYPE)
2397 << "--> OnRequestSetPreferredNetworkTest" << endl;
2398 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_PREFERRED_NETWORK_TYPE)
2399 << "--> OnRequestGetPreferredNetworkTest" << endl;
2400 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CURRENT_CELL_INFO) << " --> OnRequestGetCurrentCellInfoTest"
2401 << endl;
2402 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CELL_INFO_LIST) << " --> OnRequestGetCellInfoListTest"
2403 << endl;
2404 cout << static_cast<int32_t>(DiffInterfaceId::TEST_OPERATOR) << " --> OnRequestNetworkOperatorTest"
2405 << endl; // failed, Invalid response: nullptr, radioResponseInfo->error : 2
2406 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_NETWORKS_TO_USE)
2407 << "--> OnRequestGetNetworkSearchInformationTest"
2408 << endl; // failed, Invalid response: nullptr, radioResponseInfo->error : 2
2409 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SELECTION_MOD_FOR_NETWORKS)
2410 << "--> OnRequestGetNetworkSelectionModeTest"
2411 << endl; // failed, Invalid response: nullptr, radioResponseInfo->error : 2
2412 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_MODE_AUTOMATIC_NETWORKS)
2413 << "--> OnRequestSetNetworkSelectionModeTest"
2414 << endl; // failed, Invalid response: nullptr, radioResponseInfo->error : 2
2415 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_SIGNAL_STRENGTH) << "--> OnRequestNetworkGetRssiTest"
2416 << endl;
2417 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_CS_REG_STATUS) << "--> OnRequestGetCsRegStatusTest" << endl;
2418 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_PS_REG_STATUS) << "--> OnRequestGetPsRegStatusTest" << endl;
2419 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_PHYSICAL_CHANNEL_CONFIG)
2420 << "--> OnRequestGetPhysicalChannelConfig" << endl;
2421 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_LOCATE_UPDATES) << "--> OnRequestSetLocateUpdatesTest"
2422 << endl;
2423 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_NOTIFICATION_FILTER)
2424 << "--> OnRequestSetNotificationFilterTest" << endl;
2425 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_DEVICE_STATE) << "--> OnRequestSetDeviceStateTest" << endl;
2426 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_RRC_CONNECTION_STATE)
2427 << "--> OnRequestGetRrcConnectionStateTest" << endl;
2428 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_OPTION_MODE) << "--> OnRequestGetNrOptionModeTest"
2429 << endl;
2430 cout << static_cast<int32_t>(DiffInterfaceId::TEST_SET_NR_OPTION_MODE) << "--> OnRequestSetNrOptionModeTest"
2431 << endl;
2432 cout << static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_SSBID_INFO) << "--> OnRequestGetNrSsbIdTest" << endl;
2433 }
2434 } // namespace Telephony
2435 } // namespace OHOS
2436
2437 using namespace OHOS;
2438 using namespace OHOS::Telephony;
main()2439 int main()
2440 {
2441 int32_t slotId;
2442 std::vector<std::shared_ptr<TelRilTest::DemoHandler>> demohandler;
2443 std::unique_ptr<TelRilTest> rilManagerAndResponseTest = std::make_unique<TelRilTest>();
2444 if (rilManagerAndResponseTest == nullptr) {
2445 TELEPHONY_LOGE("rilManagerAndResponseTest is nullptr.");
2446 return TELEPHONY_ERROR;
2447 }
2448 rilManagerAndResponseTest->OnInitInterface();
2449 std::shared_ptr<AppExecFwk::EventRunner> eventRunner = AppExecFwk::EventRunner::Create("DemoHandler");
2450 if (eventRunner == nullptr) {
2451 TELEPHONY_LOGE("ERROR : AppExecFwk::EventRunner::Create(\"DemoHandler\") --> nullptr !!!");
2452 return TELEPHONY_ERROR;
2453 }
2454 for (slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
2455 demohandler.push_back(make_shared<TelRilTest::DemoHandler>(slotId, eventRunner));
2456 rilManagerAndResponseTest->OnInitForRegister(slotId, demohandler[slotId]);
2457 TELEPHONY_LOGI("OnInitForRegister(g_handler) finished -->");
2458 }
2459 eventRunner->Run();
2460 int32_t what = 1;
2461 while (what) {
2462 SimTest();
2463 DataTest();
2464 CallTest();
2465 SmsTest();
2466 NetworkTest();
2467 Promote();
2468 cout << "Please select SIM card, 0 or 1." << endl;
2469 cin >> slotId;
2470 if ((slotId != 0) && (slotId != 1)) {
2471 cout << "Invalid SIM card selected." << endl;
2472 cout << "Please select SIM card, 0 or 1." << endl;
2473 continue;
2474 }
2475 cout << "Please select a test item." << endl;
2476 cin >> what;
2477 cout << "" << endl;
2478 if (what == static_cast<int32_t>(DiffInterfaceId::TEST_EXIT)) {
2479 break;
2480 }
2481 if ((what >= static_cast<int32_t>(DiffInterfaceId::TEST_GET_SIM_CARD_STATUS)) &&
2482 (what < static_cast<int32_t>(DiffInterfaceId::TEST_EXIT))) {
2483 rilManagerAndResponseTest->OnProcessInput(slotId, what, demohandler[slotId]);
2484 }
2485 }
2486 return 0;
2487 }
2488