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