1 /*
2 * Copyright (C) 2021-2023 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
16 #include "tel_ril_test_util.h"
17
18 #include <fcntl.h>
19 #include <iostream>
20
21 #include "iservice_registry.h"
22 #include "radio_event.h"
23 #include "securec.h"
24 #include "system_ability_definition.h"
25
26 namespace OHOS {
27 namespace Telephony {
28 const std::string GTEST_STRING = "1234";
29 const std::string GTEST_STRING_PIN1 = "1234";
30 const std::string GTEST_STRING_PIN2 = "80785121";
31 const std::string GTEST_STRING_PUK1 = "19467362";
32 const std::string GTEST_STRING_PUK2 = "19467362";
33 const int32_t PW_LEN = 4;
34 const int32_t DECIMAL = 10;
35 const int32_t PHONE_NUM_LEN = 11;
36 const int32_t CID = 1;
37 const int32_t REASON = 2;
38 const int32_t P3 = 15;
39 const int32_t COMMAND = 192;
40 const int32_t FILEID = 20272;
41 const int32_t AUTHTYPE_1 = 0;
42 constexpr static const int32_t WAIT_TIME_SECOND = 20;
43 constexpr static const int32_t WAIT_TIME_SECOND_LONG = 30;
44 constexpr int32_t MAX_BUF_SIZE = 255;
45 constexpr int32_t WAIT_TELEPHONY_RETART_TIME = 60;
46 const int BANDWIDTH_HYSTERESIS_MS = 3000;
47 const int BANDWIDTH_HYSTERESIS_KBPS = 50;
48 const int MAX_DOWNLINK_LINK_BANDWIDTH[] = {100, // VoIP
49 500, // Web
50 1000, // SD
51 5000, // HD
52 10000, // file
53 20000, // 4K
54 50000, // LTE
55 100000,
56 200000, // 5G
57 500000, 1000000};
58 const int MAX_UPLINK_LINK_BANDWIDTH[] = {100, 500, 1000, 5000, 10000, 20000, 50000, 100000, 200000};
59 // send "test"
60 const std::string TEST_PDU = "A10305810180F6000004F4F29C0E";
61 // leave blank, smsc will be acquired automatically
62 const std::string TEST_SMSC_PDU = "";
63 // smsc addr
64 std::string g_smscAddr = "";
65 int32_t g_tosca = 0;
66 std::shared_ptr<Telephony::ITelRilManager> TelRilTest::telRilManager_ = nullptr;
67
SetUp()68 void TelRilTest::SetUp() {}
69
TearDown()70 void TelRilTest::TearDown() {}
71
SetUpTestCase()72 void TelRilTest::SetUpTestCase()
73 {
74 TELEPHONY_LOGI("----------TelRilTest gtest start ------------");
75 telRilManager_ = std::make_shared<TelRilManager>();
76 auto ret = telRilManager_->OnInit();
77 TELEPHONY_LOGI("----------TelRilTest setup finished ret: %{public}d ------------", ret);
78 }
79
ReStartTelephony()80 void TelRilTest::ReStartTelephony()
81 {
82 FILE *fp;
83 char buf[MAX_BUF_SIZE];
84 std::string cmd = "pidof telephony";
85 pid_t pid = -1;
86 if ((fp = popen(cmd.c_str(), "r")) != nullptr) {
87 if (fgets(buf, MAX_BUF_SIZE, fp) != nullptr) {
88 pid = atoi(buf);
89 }
90 }
91 kill(pid, SIGKILL);
92 pclose(fp);
93 sleep(WAIT_TELEPHONY_RETART_TIME);
94 }
95
TearDownTestCase()96 void TelRilTest::TearDownTestCase()
97 {
98 TELEPHONY_LOGI("----------TelRilTest gtest end ------------");
99 telRilManager_ = nullptr;
100 ReStartTelephony();
101 }
102
TelRilTest()103 TelRilTest::TelRilTest()
104 {
105 AddRequestToMap();
106 }
107
~TelRilTest()108 TelRilTest::~TelRilTest()
109 {
110 memberFuncMap_.clear();
111 }
112
GetProxy()113 sptr<ICoreService> TelRilTest::GetProxy()
114 {
115 TELEPHONY_LOGI("TelRilTest::GetProxy");
116 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
117 if (systemAbilityMgr == nullptr) {
118 TELEPHONY_LOGI("TelRilTest::GetProxy systemAbilityMgr is nullptr");
119 return nullptr;
120 }
121 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID);
122 if (remote) {
123 sptr<ICoreService> telephonyService = iface_cast<ICoreService>(remote);
124 return telephonyService;
125 } else {
126 TELEPHONY_LOGE("TelRilTest::GetProxy Get TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID fail");
127 return nullptr;
128 }
129 }
130
ProcessTest(int32_t index,int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)131 bool TelRilTest::ProcessTest(int32_t index, int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
132 {
133 auto telephonyService = GetProxy();
134 if (telephonyService == nullptr) {
135 TELEPHONY_LOGE("TelRilTest::ProcessTest telephonyService is nullptr");
136 return true;
137 }
138 bool hasSimCard = false;
139 telephonyService->HasSimCard(slotId, hasSimCard);
140 if (!hasSimCard) {
141 TELEPHONY_LOGE("TelRilTest::ProcessTest no sim card %{public}d", slotId);
142 return true;
143 }
144
145 for (auto itFunc : memberFuncMap_) {
146 int32_t val = static_cast<int32_t>(itFunc.first);
147 if (val == index) {
148 auto memberFunc = itFunc.second;
149 (this->*memberFunc)(slotId, handler);
150 return true;
151 }
152 }
153 return false;
154 }
155
AddRequestToMap()156 void TelRilTest::AddRequestToMap()
157 {
158 InitCall();
159 InitData();
160 InitSim();
161 InitSms();
162 InitNetwork();
163 InitModem();
164 }
165
InitCall()166 void TelRilTest::InitCall()
167 {
168 /* --------------------------------- CALL ----------------------------- */
169 memberFuncMap_[DiffInterfaceId::TEST_CURRENT_CALLS] = &TelRilTest::CallGetCurrentCallsStatusTest;
170 memberFuncMap_[DiffInterfaceId::TEST_CALL_DIAL] = &TelRilTest::CallDialTest;
171 memberFuncMap_[DiffInterfaceId::TEST_HANDUP_CONNECT] = &TelRilTest::CallHangupTest;
172 memberFuncMap_[DiffInterfaceId::TEST_ACCEPT_CALL] = &TelRilTest::CallAnswerTest;
173 memberFuncMap_[DiffInterfaceId::TEST_HOLD_CALL] = &TelRilTest::CallHoldTest;
174 memberFuncMap_[DiffInterfaceId::TEST_ACTIVE_CALL] = &TelRilTest::CallActiveTest;
175 memberFuncMap_[DiffInterfaceId::TEST_SWAP_CALL] = &TelRilTest::CallSwapTest;
176 memberFuncMap_[DiffInterfaceId::TEST_JOIN_CALL] = &TelRilTest::CallJoinTest;
177 memberFuncMap_[DiffInterfaceId::TEST_SPLIT_CALL] = &TelRilTest::CallSplitTest;
178 memberFuncMap_[DiffInterfaceId::TEST_REJECT_CALL] = &TelRilTest::RefusedCallTest;
179 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_WAIT] = &TelRilTest::GetCallWaitTest;
180 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_WAIT] = &TelRilTest::SetCallWaitTest;
181 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_FORWARD] = &TelRilTest::GetCallForwardTest;
182 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_FORWARD] = &TelRilTest::SetCallForwardTest;
183 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_DEAL_CLIP] = &TelRilTest::GetClipTest;
184 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_CLIP] = &TelRilTest::SetClipTest;
185 memberFuncMap_[DiffInterfaceId::TEST_GET_CALL_RESTRICTION] = &TelRilTest::GetCallRestrictionTest;
186 memberFuncMap_[DiffInterfaceId::TEST_SET_CALL_RESTRICTION] = &TelRilTest::SetCallRestrictionTest;
187 memberFuncMap_[DiffInterfaceId::TEST_SET_BARRING_PWD] = &TelRilTest::SetBarringPasswordTest;
188 memberFuncMap_[DiffInterfaceId::TEST_SEND_DTMF] = &TelRilTest::SendDtmfTest;
189 memberFuncMap_[DiffInterfaceId::TEST_START_DTMF] = &TelRilTest::StartDtmfTest;
190 memberFuncMap_[DiffInterfaceId::TEST_STOP_DTMF] = &TelRilTest::StopDtmfTest;
191 memberFuncMap_[DiffInterfaceId::TEST_SET_USSD] = &TelRilTest::SetUssdTest;
192 memberFuncMap_[DiffInterfaceId::TEST_GET_USSD] = &TelRilTest::GetUssdTest;
193 memberFuncMap_[DiffInterfaceId::TEST_SET_CMUT] = &TelRilTest::SetMuteTest;
194 memberFuncMap_[DiffInterfaceId::TEST_GET_CMUT] = &TelRilTest::GetMuteTest;
195 memberFuncMap_[DiffInterfaceId::TEST_GET_EMERGENCY_CALL_LIST] = &TelRilTest::GetEmergencyCallListTest;
196 memberFuncMap_[DiffInterfaceId::TEST_SET_VONR_STATUS] = &TelRilTest::SetVoNRSwitchTest;
197 }
198
InitData()199 void TelRilTest::InitData()
200 {
201 /* --------------------------------- DATA ----------------------------- */
202 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_INIT_APN_INFO] = &TelRilTest::DataSetInitApnInfoTest;
203 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SETUP_DATA_CALL] = &TelRilTest::DataSetupDataCallTest;
204 memberFuncMap_[DiffInterfaceId::TEST_RILCM_DEACTIVATE_DATA_CALL] = &TelRilTest::DataDisableDataCallTest;
205 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_DATA_CALL_LIST] = &TelRilTest::GetDataCallListTest;
206 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_LINK_BANDWIDTH_INFO] = &TelRilTest::GetLinkBandwidthInfoTest;
207 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_LINK_BANDWIDTH_REPORTING_RULE] =
208 &TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest;
209 memberFuncMap_[DiffInterfaceId::TEST_RILCM_SET_DATA_PERMITTED_TEST] = &TelRilTest::SetDataPermittedTest;
210 memberFuncMap_[DiffInterfaceId::TEST_RILCM_GET_LINK_CAPABILITY_TEST] = &TelRilTest::GetLinkCapabilityTest;
211 memberFuncMap_[DiffInterfaceId::TEST_RILCM_CLEAN_ALL_DATA_CONNECTIONS_TEST] = &TelRilTest::CleanAllConnectionsTest;
212 }
213
InitSim()214 void TelRilTest::InitSim()
215 {
216 /*-----------------------------------SIM----------------------------------*/
217 memberFuncMap_[DiffInterfaceId::TEST_GET_SIM_CARD_STATUS] = &TelRilTest::SimGetSimStatusTest;
218 memberFuncMap_[DiffInterfaceId::TEST_SIM_IO] = &TelRilTest::SimIccIoTest;
219 memberFuncMap_[DiffInterfaceId::TEST_GET_IMSI] = &TelRilTest::SimGetImsiTest;
220 memberFuncMap_[DiffInterfaceId::TEST_GET_SIM_LOCK_STATUS] = &TelRilTest::GetSimLockStatusTest;
221 memberFuncMap_[DiffInterfaceId::TEST_SET_SIM_LOCK] = &TelRilTest::SetSimLockTest;
222 memberFuncMap_[DiffInterfaceId::TEST_UNSET_SIM_LOCK] = &TelRilTest::UnSetSimLockTest;
223 memberFuncMap_[DiffInterfaceId::TEST_GET_CHANGE_SIM_PASSWD] = &TelRilTest::ChangeSimPasswordTest;
224 memberFuncMap_[DiffInterfaceId::TEST_ENTER_SIM_PIN] = &TelRilTest::EnterSimPinTest;
225 memberFuncMap_[DiffInterfaceId::TEST_RADIO_RESTART] = &TelRilTest::RadioRestartTest;
226 memberFuncMap_[DiffInterfaceId::TEST_ENTER_ERROR_PIN] = &TelRilTest::EnterErrorPinTest;
227 memberFuncMap_[DiffInterfaceId::TEST_UNLOCK_SIM_PIN] = &TelRilTest::UnlockSimPinTest;
228 memberFuncMap_[DiffInterfaceId::TEST_SET_PIN2_LOCK] = &TelRilTest::SetPin2LockTest;
229 memberFuncMap_[DiffInterfaceId::TEST_ENTER_SIM_PIN2] = &TelRilTest::EnterSimPin2Test;
230 memberFuncMap_[DiffInterfaceId::TEST_ENTER_ERROR_PIN2] = &TelRilTest::EnterErrorPin2Test;
231 memberFuncMap_[DiffInterfaceId::TEST_UNLOCK_SIM_PIN2] = &TelRilTest::UnlockSimPin2Test;
232 memberFuncMap_[DiffInterfaceId::TEST_UNSET_PIN2_LOCK] = &TelRilTest::UnSetPin2LockTest;
233 memberFuncMap_[DiffInterfaceId::TEST_ENABLE_SIM_CARD] = &TelRilTest::EnableSimCardTest;
234 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_TERMINAL_RESPONSE] = &TelRilTest::SendTerminalResponseCmdTest;
235 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_ENVELOPE] = &TelRilTest::SendEnvelopeCmdTest;
236 memberFuncMap_[DiffInterfaceId::TEST_STK_SEND_CALL_SETUP_REQUEST_RESULT] =
237 &TelRilTest::SendCallSetupRequestResultTest;
238 memberFuncMap_[DiffInterfaceId::TEST_GET_RADIO_PROTOCOL] = &TelRilTest::GetRadioProtocolTest;
239 memberFuncMap_[DiffInterfaceId::TEST_SET_RADIO_PROTOCOL] = &TelRilTest::SetRadioProtocolTest;
240 }
241
InitSms()242 void TelRilTest::InitSms()
243 {
244 /* --------------------------------- SMS ----------------------------- */
245 memberFuncMap_[DiffInterfaceId::TEST_SEND_SMS] = &TelRilTest::SendRilCmSmsTest;
246 memberFuncMap_[DiffInterfaceId::TEST_STORAGE_SMS] = &TelRilTest::StorageRilCmSmsTest;
247 memberFuncMap_[DiffInterfaceId::TEST_DELETE_SMS] = &TelRilTest::DeleteRilCmSmsTest;
248 memberFuncMap_[DiffInterfaceId::TEST_UPDATE_SMS] = &TelRilTest::UpdateRilCmSmsTest;
249 memberFuncMap_[DiffInterfaceId::TEST_SET_SMS_CENTER_ADDRESS] = &TelRilTest::SetRilCmSmsCenterAddressTest;
250 memberFuncMap_[DiffInterfaceId::TEST_GET_SMS_CENTER_ADDRESS] = &TelRilTest::GetRilCmSmsCenterAddressTest;
251 memberFuncMap_[DiffInterfaceId::TEST_SET_CB_CONFIG] = &TelRilTest::SetRilCmCBConfigTest;
252 memberFuncMap_[DiffInterfaceId::TEST_SET_CDMA_CB_CONFIG] = &TelRilTest::SetRilCmCdmaCBConfigTest;
253 memberFuncMap_[DiffInterfaceId::TEST_GET_CB_CONFIG] = &TelRilTest::GetRilCmCBConfigTest;
254 memberFuncMap_[DiffInterfaceId::TEST_GET_CDMA_CB_CONFIG] = &TelRilTest::GetRilCmCdmaCBConfigTest;
255 memberFuncMap_[DiffInterfaceId::TEST_SEND_SMS_EXPECT_MORE] = &TelRilTest::SmsSendSmsExpectMoreTest;
256 memberFuncMap_[DiffInterfaceId::TEST_SEND_SMS_ACK] = &TelRilTest::SmsAcknowledgeTest;
257 memberFuncMap_[DiffInterfaceId::TEST_ADD_CDMA_SMS] = &TelRilTest::AddRilCmCdmaSmsTest;
258 memberFuncMap_[DiffInterfaceId::TEST_DEL_CDMA_SMS] = &TelRilTest::DelRilCmCdmaSmsTest;
259 memberFuncMap_[DiffInterfaceId::TEST_UPDATE_CDMA_SMS] = &TelRilTest::UpdateRilCmCdmaSmsTest;
260 }
261
InitNetwork()262 void TelRilTest::InitNetwork()
263 {
264 /* --------------------------------- NETWORK ----------------------------- */
265 memberFuncMap_[DiffInterfaceId::TEST_OPERATOR] = &TelRilTest::NetworkOperatorTest;
266 memberFuncMap_[DiffInterfaceId::TEST_GET_RILCM_VOICE_REGISTRATION_STATE] =
267 &TelRilTest::NetworkVoiceRegistrationStateTest;
268 memberFuncMap_[DiffInterfaceId::TEST_GET_RILCM_DATA_REGISTRATION_STATE] =
269 &TelRilTest::NetworkDataRegistrationStateTest;
270 memberFuncMap_[DiffInterfaceId::TEST_GET_NETWORKS_TO_USE] = &TelRilTest::GetNetworkSearchInformationTest;
271 memberFuncMap_[DiffInterfaceId::TEST_GET_SELECTION_MOD_FOR_NETWORKS] = &TelRilTest::GetNetworkSelectionModeTest;
272 memberFuncMap_[DiffInterfaceId::TEST_SET_MODE_AUTOMATIC_NETWORKS] = &TelRilTest::SetNetworkSelectionModeTest;
273 memberFuncMap_[DiffInterfaceId::TEST_GET_PREFERRED_NETWORK_TYPE] = &TelRilTest::GetPreferredNetworkParaTest;
274 memberFuncMap_[DiffInterfaceId::TEST_SET_PREFERRED_NETWORK_TYPE] = &TelRilTest::SetPreferredNetworkParaTest;
275 memberFuncMap_[DiffInterfaceId::TEST_GET_IMEI] = &TelRilTest::GetImeiTest;
276 memberFuncMap_[DiffInterfaceId::TEST_GET_IMEISV] = &TelRilTest::GetImeiSvTest;
277 memberFuncMap_[DiffInterfaceId::TEST_GET_MEID] = &TelRilTest::GetMeidTest;
278 memberFuncMap_[DiffInterfaceId::TEST_GET_VOICE_RADIO_INFO] = &TelRilTest::GetVoiceRadioTechnologyTest;
279 memberFuncMap_[DiffInterfaceId::TEST_GET_PHYSICAL_CHANNEL_CONFIG] = &TelRilTest::GetPhysicalChannelConfigTest;
280 memberFuncMap_[DiffInterfaceId::TEST_SET_LOCATE_UPDATES] = &TelRilTest::SetLocateUpdatesTest;
281 memberFuncMap_[DiffInterfaceId::TEST_SET_NOTIFICATION_FILTER] = &TelRilTest::SetNotificationFilterTest;
282 memberFuncMap_[DiffInterfaceId::TEST_SET_DEVICE_STATE] = &TelRilTest::SetDeviceStateTest;
283 memberFuncMap_[DiffInterfaceId::TEST_GET_RRC_CONNECTION_STATE] = &TelRilTest::GetRrcConnectionStateTest;
284 memberFuncMap_[DiffInterfaceId::TEST_GET_NR_OPTION_MODE] = &TelRilTest::GetNrOptionModeTest;
285 memberFuncMap_[DiffInterfaceId::TEST_SET_NR_OPTION_MODE] = &TelRilTest::SetNrOptionModeTest;
286 memberFuncMap_[DiffInterfaceId::TEST_GET_NR_SSBID_INFO] = &TelRilTest::GetNrSsbIdTest;
287 memberFuncMap_[DiffInterfaceId::TEST_GET_CELL_INFO_LIST_TYPE] = &TelRilTest::GetCellInfoListTest;
288 }
289
InitModem()290 void TelRilTest::InitModem()
291 {
292 /* --------------------------------- MODEM -------------------------- */
293 memberFuncMap_[DiffInterfaceId::TEST_GET_SIGNAL_STRENGTH] = &TelRilTest::NetworkGetRssiTest;
294 memberFuncMap_[DiffInterfaceId::TEST_SET_POWER_STATE] = &TelRilTest::SetRadioStateTest;
295 memberFuncMap_[DiffInterfaceId::TEST_GET_POWER_STATE] = &TelRilTest::GetRadioStateTest;
296 }
297
298 /**
299 * @brief Get current calls status
300 *
301 * @param handler
302 */
CallGetCurrentCallsStatusTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)303 void TelRilTest::CallGetCurrentCallsStatusTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
304 {
305 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_CURRENT_CALLS);
306 auto event = AppExecFwk::InnerEvent::Get(eventId);
307 if (event != nullptr && telRilManager_ != nullptr) {
308 event->SetOwner(handler);
309 TELEPHONY_LOGI("TelRilTest::CallGetCurrentCallsStatusTest -->");
310 telRilManager_->GetCallList(slotId, event);
311 TELEPHONY_LOGI("TelRilTest::CallGetCurrentCallsStatusTest --> finished");
312 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
313 ASSERT_TRUE(syncResult);
314 }
315 }
316
317 /************************************** SIM test func *******************************************/
318 /**
319 * @brief Get SIM card status
320 *
321 * @param handler
322 */
SimGetSimStatusTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)323 void TelRilTest::SimGetSimStatusTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
324 {
325 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_GET_STATUS);
326 auto event = AppExecFwk::InnerEvent::Get(eventId);
327 if (event != nullptr && telRilManager_ != nullptr) {
328 event->SetOwner(handler);
329 TELEPHONY_LOGI("TelRilTest::SimGetSimStatusTest -->");
330 telRilManager_->GetSimStatus(slotId, event);
331 TELEPHONY_LOGI("TelRilTest::SimGetSimStatusTest --> finished");
332 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
333 ASSERT_TRUE(syncResult);
334 }
335 }
336
337 /**
338 * @brief Get SIM card IO
339 *
340 * @param handler
341 */
SimIccIoTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)342 void TelRilTest::SimIccIoTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
343 {
344 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_IO);
345 auto event = AppExecFwk::InnerEvent::Get(eventId);
346 if (event != nullptr && telRilManager_ != nullptr) {
347 event->SetOwner(handler);
348 TELEPHONY_LOGI("TelRilTest::SimIccIoTest -->");
349 SimIoRequestInfo msg;
350 msg.command = COMMAND;
351 msg.fileId = FILEID;
352 msg.p1 = 0;
353 msg.p2 = 0;
354 msg.p3 = P3;
355 msg.data = "";
356 msg.path = "3F007F105F3A";
357 msg.pin2 = "";
358 telRilManager_->GetSimIO(slotId, msg, event);
359 TELEPHONY_LOGI("TelRilTest::SimIccIoTest --> finished");
360 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
361 ASSERT_TRUE(syncResult);
362 }
363 }
364
365 /**
366 * @brief Get International Mobile Subscriber Identity
367 *
368 * @param handler
369 */
SimGetImsiTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)370 void TelRilTest::SimGetImsiTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
371 {
372 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_GET_IMSI);
373 auto event = AppExecFwk::InnerEvent::Get(eventId);
374 if (event != nullptr && telRilManager_ != nullptr) {
375 event->SetOwner(handler);
376 TELEPHONY_LOGI("TelRilTest::SimGetImsiTest -->");
377 telRilManager_->GetImsi(slotId, event);
378 TELEPHONY_LOGI("TelRilTest::SimGetImsiTest --> finished");
379 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
380 ASSERT_TRUE(syncResult);
381 }
382 }
383
384 /**
385 * @brief Get SIM card lock status
386 *
387 * @param handler
388 */
GetSimLockStatusTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)389 void TelRilTest::GetSimLockStatusTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
390 {
391 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_GET_LOCK_STATUS);
392 auto event = AppExecFwk::InnerEvent::Get(eventId);
393 if (event != nullptr && telRilManager_ != nullptr) {
394 event->SetOwner(handler);
395 std::string fac = FAC_PIN_LOCK;
396 TELEPHONY_LOGI("TelRilTest::GetSimLockStatusTest -->");
397 telRilManager_->GetSimLockStatus(slotId, fac, event);
398 TELEPHONY_LOGI("TelRilTest::GetSimLockStatusTest --> finished");
399 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
400 ASSERT_TRUE(syncResult);
401 }
402 }
403
404 /**
405 * @brief Set SIM card lock status
406 *
407 * @param handler
408 */
SetSimLockTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)409 void TelRilTest::SetSimLockTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
410 {
411 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_SET_LOCK);
412 auto event = AppExecFwk::InnerEvent::Get(eventId);
413 if (event != nullptr && telRilManager_ != nullptr) {
414 event->SetOwner(handler);
415 SimLockParam simLockParam;
416 simLockParam.fac = FAC_PIN_LOCK;
417 simLockParam.mode = static_cast<int32_t>(LockState::LOCK_ON);
418 simLockParam.passwd = GTEST_STRING_PIN1;
419 TELEPHONY_LOGI("TelRilTest::SetSimLockTest -->");
420 telRilManager_->SetSimLock(slotId, simLockParam, event);
421 TELEPHONY_LOGI("TelRilTest::SetSimLockTest --> finished");
422 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
423 ASSERT_TRUE(syncResult);
424 }
425 }
426
427 /**
428 * @brief UnSet SIM card lock status
429 *
430 * @param handler
431 */
UnSetSimLockTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)432 void TelRilTest::UnSetSimLockTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
433 {
434 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_SET_LOCK);
435 auto event = AppExecFwk::InnerEvent::Get(eventId);
436 if (event != nullptr && telRilManager_ != nullptr) {
437 event->SetOwner(handler);
438 SimLockParam simLockParam;
439 simLockParam.fac = FAC_PIN_LOCK;
440 simLockParam.mode = static_cast<int32_t>(LockState::LOCK_OFF);
441 simLockParam.passwd = GTEST_STRING_PIN1;
442 TELEPHONY_LOGI("TelRilTest::UnSetSimLockTest -->");
443 telRilManager_->SetSimLock(slotId, simLockParam, event);
444 TELEPHONY_LOGI("TelRilTest::UnSetSimLockTest --> finished");
445 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
446 ASSERT_TRUE(syncResult);
447 }
448 }
449
450 /**
451 * @brief Change SIM card Password
452 *
453 * @param handler
454 */
ChangeSimPasswordTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)455 void TelRilTest::ChangeSimPasswordTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
456 {
457 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_CHANGE_PASSWD);
458 auto event = AppExecFwk::InnerEvent::Get(eventId);
459 if (event != nullptr && telRilManager_ != nullptr) {
460 event->SetOwner(handler);
461 SimPasswordParam simPassword;
462 simPassword.passwordLength = PW_LEN;
463 simPassword.fac = FAC_PIN_LOCK;
464 simPassword.oldPassword = GTEST_STRING_PIN1;
465 simPassword.newPassword = GTEST_STRING_PIN1;
466 TELEPHONY_LOGI("TelRilTest::ChangeSimPasswordTest -->");
467 telRilManager_->ChangeSimPassword(slotId, simPassword, event);
468 TELEPHONY_LOGI("TelRilTest::ChangeSimPasswordTest --> finished");
469 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
470 ASSERT_TRUE(syncResult);
471 }
472 }
473
474 /**
475 * @brief Restart Radio
476 *
477 * @param handler
478 */
RadioRestartTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)479 void TelRilTest::RadioRestartTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
480 {
481 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_STATUS);
482 auto event = AppExecFwk::InnerEvent::Get(eventId);
483 if (event != nullptr && telRilManager_ != nullptr) {
484 event->SetOwner(handler);
485 uint8_t funOffline = 4;
486 uint8_t rstOffline = 1;
487 telRilManager_->SetRadioState(slotId, funOffline, rstOffline, event);
488 TELEPHONY_LOGI("TelRilTest::RadioRestartTest1 -->");
489 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND_LONG);
490 ASSERT_TRUE(syncResult);
491
492 uint8_t funReboot = 6;
493 uint8_t rstReboot = 1;
494 telRilManager_->SetRadioState(slotId, funReboot, rstReboot, event);
495 TELEPHONY_LOGI("TelRilTest::RadioRestartTest2 -->");
496 bool syncResult2 = WaitGetResult(eventId, handler, WAIT_TIME_SECOND_LONG);
497 ASSERT_TRUE(syncResult2);
498 }
499 }
500
501 /**
502 * @brief Enter SIM card pin code
503 *
504 * @param handler
505 */
EnterSimPinTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)506 void TelRilTest::EnterSimPinTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
507 {
508 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_ENTER_PIN);
509 auto event = AppExecFwk::InnerEvent::Get(eventId);
510 if (event != nullptr && telRilManager_ != nullptr) {
511 event->SetOwner(handler);
512 std::string pin = GTEST_STRING_PIN1;
513 TELEPHONY_LOGI("TelRilTest::EnterSimPinTest -->");
514 telRilManager_->UnlockPin(slotId, pin, event);
515 TELEPHONY_LOGI("TelRilTest::EnterSimPinTest --> finished");
516 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
517 ASSERT_TRUE(syncResult);
518 }
519 }
520
521 /**
522 * @brief Enter error pin code
523 *
524 * @param handler
525 */
EnterErrorPinTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)526 void TelRilTest::EnterErrorPinTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
527 {
528 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_ENTER_PIN);
529 auto event = AppExecFwk::InnerEvent::Get(eventId);
530 if (event != nullptr && telRilManager_ != nullptr) {
531 event->SetOwner(handler);
532 std::string pin = "1111";
533 TELEPHONY_LOGI("TelRilTest::EnterErrorPinTest -->");
534 telRilManager_->UnlockPin(slotId, pin, event);
535 TELEPHONY_LOGI("TelRilTest::EnterErrorPinTest --> finished");
536 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
537 ASSERT_TRUE(syncResult);
538 }
539 }
540
541 /**
542 * @brief Unlock SIM card pin code
543 *
544 * @param handler
545 */
UnlockSimPinTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)546 void TelRilTest::UnlockSimPinTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
547 {
548 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_UNLOCK_PIN);
549 auto event = AppExecFwk::InnerEvent::Get(eventId);
550 if (event != nullptr && telRilManager_ != nullptr) {
551 event->SetOwner(handler);
552 std::string puk = GTEST_STRING_PUK1;
553 std::string pin = GTEST_STRING_PIN1;
554 TELEPHONY_LOGI("TelRilTest::UnlockSimPinTest -->");
555 telRilManager_->UnlockPuk(slotId, puk, pin, event);
556 TELEPHONY_LOGI("TelRilTest::UnlockSimPinTest --> finished");
557 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
558 ASSERT_TRUE(syncResult);
559 }
560 }
561
562 /**
563 * @brief Set SIM card PIN2 lock status
564 *
565 * @param handler
566 */
SetPin2LockTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)567 void TelRilTest::SetPin2LockTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
568 {
569 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_SET_LOCK);
570 auto event = AppExecFwk::InnerEvent::Get(eventId);
571 if (event != nullptr && telRilManager_ != nullptr) {
572 event->SetOwner(handler);
573 SimLockParam simLockParam;
574 simLockParam.fac = FDN_PIN2_LOCK;
575 simLockParam.mode = static_cast<int32_t>(LockState::LOCK_ON);
576 simLockParam.passwd = GTEST_STRING_PIN2;
577 TELEPHONY_LOGI("TelRilTest::SetPIN2LockTest -->");
578 telRilManager_->SetSimLock(slotId, simLockParam, event);
579 TELEPHONY_LOGI("TelRilTest::SetPin2LockTest --> finished");
580 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
581 ASSERT_TRUE(syncResult);
582 }
583 }
584
585 /**
586 * @brief Set SIM card PIN2 lock status
587 *
588 * @param handler
589 */
UnSetPin2LockTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)590 void TelRilTest::UnSetPin2LockTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
591 {
592 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_SET_LOCK);
593 auto event = AppExecFwk::InnerEvent::Get(eventId);
594 if (event != nullptr && telRilManager_ != nullptr) {
595 event->SetOwner(handler);
596 SimLockParam simLockParam;
597 simLockParam.fac = FDN_PIN2_LOCK;
598 simLockParam.mode = static_cast<int32_t>(LockState::LOCK_OFF);
599 simLockParam.passwd = GTEST_STRING_PIN2;
600 TELEPHONY_LOGI("TelRilTest::UnSetPin2LockTest -->");
601 telRilManager_->SetSimLock(slotId, simLockParam, event);
602 TELEPHONY_LOGI("TelRilTest::UnSetPin2LockTest --> finished");
603 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
604 ASSERT_TRUE(syncResult);
605 }
606 }
607
608 /**
609 * @brief Enter SIM card pin2 code
610 *
611 * @param handler
612 */
EnterSimPin2Test(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)613 void TelRilTest::EnterSimPin2Test(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
614 {
615 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_ENTER_PIN2);
616 auto event = AppExecFwk::InnerEvent::Get(eventId);
617 if (event != nullptr && telRilManager_ != nullptr) {
618 event->SetOwner(handler);
619 std::string pin2 = GTEST_STRING_PIN2;
620 TELEPHONY_LOGI("TelRilTest::EnterSimPin2Test -->");
621 telRilManager_->UnlockPin2(slotId, pin2, event);
622 TELEPHONY_LOGI("TelRilTest::EnterSimPin2Test --> finished");
623 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
624 ASSERT_TRUE(syncResult);
625 }
626 }
627
628 /**
629 * @brief Enter Error pin2 code
630 *
631 * @param handler
632 */
EnterErrorPin2Test(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)633 void TelRilTest::EnterErrorPin2Test(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
634 {
635 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_ENTER_PIN2);
636 auto event = AppExecFwk::InnerEvent::Get(eventId);
637 if (event != nullptr && telRilManager_ != nullptr) {
638 event->SetOwner(handler);
639 std::string pin2 = "2222";
640 TELEPHONY_LOGI("TelRilTest::EnterErrorPin2Test -->");
641 telRilManager_->UnlockPin2(slotId, pin2, event);
642 TELEPHONY_LOGI("TelRilTest::EnterErrorPin2Test --> finished");
643 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
644 ASSERT_TRUE(syncResult);
645 }
646 }
647
648 /**
649 * @brief Unlock SIM card pin2 code
650 *
651 * @param handler
652 */
UnlockSimPin2Test(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)653 void TelRilTest::UnlockSimPin2Test(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
654 {
655 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_UNLOCK_PIN2);
656 auto event = AppExecFwk::InnerEvent::Get(eventId);
657 if (event != nullptr && telRilManager_ != nullptr) {
658 event->SetOwner(handler);
659 std::string puk2 = GTEST_STRING_PUK2;
660 std::string pin2 = GTEST_STRING_PIN2;
661 TELEPHONY_LOGI("TelRilTest::UnlockSimPin2Test -->");
662 telRilManager_->UnlockPuk2(slotId, puk2, pin2, event);
663 TELEPHONY_LOGI("TelRilTest::UnlockSimPin2Test --> finished");
664 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
665 ASSERT_TRUE(syncResult);
666 }
667 }
668
669 /**
670 * @brief Enable SIM card
671 *
672 * @param handler
673 */
EnableSimCardTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)674 void TelRilTest::EnableSimCardTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
675 {
676 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SIM_CARD_ENABLED);
677 auto event = AppExecFwk::InnerEvent::Get(eventId);
678 if (event != nullptr && telRilManager_ != nullptr) {
679 event->SetOwner(handler);
680 int index = 0;
681 int enable = 0;
682 TELEPHONY_LOGI("TelRilTest::EnableSimCardTest -->");
683 telRilManager_->SetActiveSim(slotId, index, enable, event);
684 TELEPHONY_LOGI("TelRilTest::EnableSimCardTest --> finished");
685 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
686 ASSERT_TRUE(syncResult);
687 }
688 }
689
690 /**
691 * @brief Get radio protocol
692 *
693 * @param handler
694 */
GetRadioProtocolTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)695 void TelRilTest::GetRadioProtocolTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
696 {
697 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_RADIO_PROTOCOL);
698 auto event = AppExecFwk::InnerEvent::Get(eventId);
699 if (event == nullptr || telRilManager_ == nullptr) {
700 TELEPHONY_LOGE("TelRilTest::GetRadioProtocolTest telRilManager_ or event is nullptr");
701 return;
702 }
703 event->SetOwner(handler);
704 TELEPHONY_LOGI("TelRilTest::GetRadioProtocolTest -->");
705 telRilManager_->GetRadioProtocol(slotId, event);
706 TELEPHONY_LOGI("TelRilTest::GetRadioProtocolTest --> finished");
707 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
708 ASSERT_TRUE(syncResult);
709 }
710
711 /**
712 * @brief Set radio protocol
713 *
714 * @param handler
715 */
SetRadioProtocolTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)716 void TelRilTest::SetRadioProtocolTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
717 {
718 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_RADIO_PROTOCOL);
719 auto event = AppExecFwk::InnerEvent::Get(eventId);
720 if (event == nullptr || telRilManager_ == nullptr) {
721 TELEPHONY_LOGE("TelRilTest::SetRadioProtocolTest telRilManager_ or event is nullptr");
722 return;
723 }
724 event->SetOwner(handler);
725 TELEPHONY_LOGI("TelRilTest::SetRadioProtocolTest -->");
726 RadioProtocol protocol;
727 protocol.sessionId = 1;
728 protocol.phase = RadioProtocolPhase::RADIO_PROTOCOL_PHASE_CHECK;
729 protocol.technology = (int32_t)RadioProtocolTech::RADIO_PROTOCOL_TECH_LTE;
730 protocol.modemId = 0;
731 protocol.status = RadioProtocolStatus::RADIO_PROTOCOL_STATUS_NONE;
732 telRilManager_->SetRadioProtocol(slotId, protocol, event);
733 TELEPHONY_LOGI("TelRilTest::SetRadioProtocolTest --> finished");
734 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
735 ASSERT_TRUE(syncResult);
736 }
737
738 /**
739 * @brief Send terminal response command
740 *
741 * @param handler
742 */
SendTerminalResponseCmdTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)743 void TelRilTest::SendTerminalResponseCmdTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
744 {
745 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_STK_SEND_TERMINAL_RESPONSE);
746 auto event = AppExecFwk::InnerEvent::Get(eventId);
747 if (event != nullptr && telRilManager_ != nullptr) {
748 event->SetOwner(handler);
749 TELEPHONY_LOGI("TelRilTest::SendTerminalResponseCmdTest -->");
750 telRilManager_->SendTerminalResponseCmd(slotId, "", event);
751 TELEPHONY_LOGI("TelRilTest::SendTerminalResponseCmdTest --> finished");
752 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
753 ASSERT_TRUE(syncResult);
754 }
755 }
756
757 /**
758 * @brief Send envelope command
759 *
760 * @param handler
761 */
SendEnvelopeCmdTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)762 void TelRilTest::SendEnvelopeCmdTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
763 {
764 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_STK_SEND_ENVELOPE);
765 auto event = AppExecFwk::InnerEvent::Get(eventId);
766 if (event != nullptr && telRilManager_ != nullptr) {
767 event->SetOwner(handler);
768 TELEPHONY_LOGI("TelRilTest::SendEnvelopeCmdTest -->");
769 telRilManager_->SendEnvelopeCmd(slotId, "", event);
770 TELEPHONY_LOGI("TelRilTest::SendEnvelopeCmdTest --> finished");
771 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
772 ASSERT_TRUE(syncResult);
773 }
774 }
775
776 /**
777 * @brief Send Call Setup Request Result command
778 *
779 * @param handler
780 */
SendCallSetupRequestResultTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)781 void TelRilTest::SendCallSetupRequestResultTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
782 {
783 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_STK_SEND_CALL_SETUP_REQUEST_RESULT);
784 auto event = AppExecFwk::InnerEvent::Get(eventId);
785 if (event != nullptr && telRilManager_ != nullptr) {
786 event->SetOwner(handler);
787 TELEPHONY_LOGI("TelRilTest::SendCallSetupRequestResultTest -->");
788 telRilManager_->SendCallSetupRequestResult(slotId, true, event);
789 TELEPHONY_LOGI("TelRilTest::SendCallSetupRequestResultTest --> finished");
790 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
791 ASSERT_TRUE(syncResult);
792 }
793 }
794
795 /************************************** SIM test func *******************************************/
796 /**
797 * @brief Get Received Signal Strength Indication
798 *
799 * @param handler
800 */
NetworkGetRssiTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)801 void TelRilTest::NetworkGetRssiTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
802 {
803 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_SIGNAL_STRENGTH);
804 auto event = AppExecFwk::InnerEvent::Get(eventId);
805 if (event != nullptr && telRilManager_ != nullptr) {
806 event->SetOwner(handler);
807 TELEPHONY_LOGI("TelRilTest::NetworkGetRssiTest -->");
808 telRilManager_->GetSignalStrength(slotId, event);
809 TELEPHONY_LOGI("TelRilTest::NetworkGetRssiTest --> finished");
810 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
811 ASSERT_TRUE(syncResult);
812 }
813 }
814
815 /**
816 * @brief Call dial
817 *
818 * @param handler
819 */
CallDialTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)820 void TelRilTest::CallDialTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
821 {
822 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_DIAL);
823 auto event = AppExecFwk::InnerEvent::Get(eventId);
824 if (event == nullptr || telRilManager_ == nullptr) {
825 TELEPHONY_LOGI("TelRilTest::CallDialTest failed!!!!");
826 return;
827 }
828
829 std::string phoneNum = GetRandPhoneNum(PHONE_NUM_LEN);
830 int32_t clirMode; /* Calling Line Identification Restriction . From TS 27.007 V3.4.0 (2000-03) */
831 event->SetOwner(handler);
832 clirMode = 0; // use subscription default value
833 TELEPHONY_LOGI("TelRilTest::CallDialTest -->");
834 telRilManager_->Dial(slotId, phoneNum, clirMode, event);
835 TELEPHONY_LOGI("TelRilTest::CallDialTest --> finished");
836 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
837 ASSERT_TRUE(syncResult);
838 }
839
840 /**
841 * @brief Reject call
842 *
843 * @param handler
844 */
RefusedCallTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)845 void TelRilTest::RefusedCallTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
846 {
847 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_REJECT_CALL);
848 auto event = AppExecFwk::InnerEvent::Get(eventId);
849 if (event != nullptr && telRilManager_ != nullptr) {
850 event->SetOwner(handler);
851 TELEPHONY_LOGI("TelRilTest::RefusedCallTest -->");
852 telRilManager_->Reject(slotId, event);
853 TELEPHONY_LOGI("TelRilTest::RefusedCallTest --> finished");
854 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
855 ASSERT_TRUE(syncResult);
856 }
857 }
858
859 /**
860 * @brief Get call waiting
861 *
862 * @param handler
863 */
GetCallWaitTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)864 void TelRilTest::GetCallWaitTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
865 {
866 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CALL_WAIT);
867 auto event = AppExecFwk::InnerEvent::Get(eventId);
868 if (event != nullptr && telRilManager_ != nullptr) {
869 event->SetOwner(handler);
870 TELEPHONY_LOGI("TelRilTest::GetCallWaitTest -->");
871 telRilManager_->GetCallWaiting(slotId, event);
872 TELEPHONY_LOGI("TelRilTest::GetCallWaitTest --> finished");
873 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
874 ASSERT_TRUE(syncResult);
875 }
876 }
877
878 /**
879 * @brief Set call waiting
880 *
881 * @param handler
882 */
SetCallWaitTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)883 void TelRilTest::SetCallWaitTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
884 {
885 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CALL_WAIT);
886 auto event = AppExecFwk::InnerEvent::Get(eventId);
887 if (event == nullptr || telRilManager_ == nullptr) {
888 return;
889 }
890 event->SetOwner(handler);
891 int32_t operating = 0;
892 TELEPHONY_LOGI("TelRilTest::SetCallWaitTest -->");
893 telRilManager_->SetCallWaiting(slotId, operating, event);
894 TELEPHONY_LOGI("TelRilTest::SetCallWaitTest --> finished");
895 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
896 ASSERT_TRUE(syncResult);
897 }
898
899 /**
900 * @brief Call hangup
901 *
902 * @param handler
903 */
CallHangupTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)904 void TelRilTest::CallHangupTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
905 {
906 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_HANGUP_CONNECT);
907 auto event = AppExecFwk::InnerEvent::Get(eventId);
908 if (event != nullptr && telRilManager_ != nullptr) {
909 event->SetOwner(handler);
910 TELEPHONY_LOGI("TelRilTest::CallHangupTest -->");
911 telRilManager_->Hangup(slotId, static_cast<int>(event->GetInnerEventId()), event);
912 TELEPHONY_LOGI("TelRilTest::CallHangupTest --> finished");
913 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
914 ASSERT_TRUE(syncResult);
915 }
916 }
917
918 /**
919 * @brief Answer the call
920 *
921 * @param handler
922 */
CallAnswerTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)923 void TelRilTest::CallAnswerTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
924 {
925 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_ACCEPT_CALL);
926 auto event = AppExecFwk::InnerEvent::Get(eventId);
927 if (event != nullptr && telRilManager_ != nullptr) {
928 event->SetOwner(handler);
929 TELEPHONY_LOGI("TelRilTest::CallAnswerTest -->");
930 telRilManager_->Answer(slotId, event);
931 TELEPHONY_LOGI("TelRilTest::CallAnswerTest --> finished");
932 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
933 ASSERT_TRUE(syncResult);
934 }
935 }
936
937 /**
938 * @brief Call on hold
939 *
940 * @param handler
941 */
CallHoldTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)942 void TelRilTest::CallHoldTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
943 {
944 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_HOLD_CALL);
945 auto event = AppExecFwk::InnerEvent::Get(eventId);
946 if (event != nullptr && telRilManager_ != nullptr) {
947 event->SetOwner(handler);
948 TELEPHONY_LOGI("TelRilTest::CallHoldTest -->");
949 telRilManager_->HoldCall(slotId, event);
950 TELEPHONY_LOGI("TelRilTest::CallHoldTest --> finished");
951 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
952 ASSERT_TRUE(syncResult);
953 }
954 }
955
956 /**
957 * @brief Call activation
958 *
959 * @param handler
960 */
CallActiveTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)961 void TelRilTest::CallActiveTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
962 {
963 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_ACTIVE_CALL);
964 auto event = AppExecFwk::InnerEvent::Get(eventId);
965 if (event != nullptr && telRilManager_ != nullptr) {
966 event->SetOwner(handler);
967 TELEPHONY_LOGI("TelRilTest::CallActiveTest -->");
968 telRilManager_->UnHoldCall(slotId, event);
969 TELEPHONY_LOGI("TelRilTest::CallActiveTest --> finished");
970 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
971 ASSERT_TRUE(syncResult);
972 }
973 }
974
975 /**
976 * @brief Call switch
977 *
978 * @param handler
979 */
CallSwapTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)980 void TelRilTest::CallSwapTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
981 {
982 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SWAP_CALL);
983 auto event = AppExecFwk::InnerEvent::Get(eventId);
984 if (event != nullptr && telRilManager_ != nullptr) {
985 event->SetOwner(handler);
986 TELEPHONY_LOGI("TelRilTest::CallSwapTest -->");
987 telRilManager_->SwitchCall(slotId, event);
988 TELEPHONY_LOGI("TelRilTest::CallSwapTest --> finished");
989 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
990 ASSERT_TRUE(syncResult);
991 }
992 }
993
994 /**
995 * @brief Get Voice Registration State
996 *
997 * @param handler
998 */
NetworkVoiceRegistrationStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)999 void TelRilTest::NetworkVoiceRegistrationStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1000 {
1001 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_VOICE_REG_STATE);
1002 auto event = AppExecFwk::InnerEvent::Get(eventId);
1003 if (event != nullptr && telRilManager_ != nullptr) {
1004 event->SetOwner(handler);
1005 TELEPHONY_LOGI("TelRilTest::NetworkVoiceRegistrationStateTest -->");
1006 telRilManager_->GetCsRegStatus(slotId, event);
1007 TELEPHONY_LOGI("TelRilTest::NetworkVoiceRegistrationStateTest --> finished");
1008 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1009 ASSERT_TRUE(syncResult);
1010 }
1011 }
1012
1013 /**
1014 * @brief Get Data Registration State
1015 *
1016 * @param handler
1017 */
NetworkDataRegistrationStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1018 void TelRilTest::NetworkDataRegistrationStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1019 {
1020 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_DATA_REG_STATE);
1021 auto event = AppExecFwk::InnerEvent::Get(eventId);
1022 if (event != nullptr && telRilManager_ != nullptr) {
1023 event->SetOwner(handler);
1024 TELEPHONY_LOGI("TelRilTest::NetworkDataRegistrationStateTest -->");
1025 telRilManager_->GetPsRegStatus(slotId, event);
1026 TELEPHONY_LOGI("TelRilTest::NetworkDataRegistrationStateTest --> finished");
1027 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1028 ASSERT_TRUE(syncResult);
1029 }
1030 }
1031
1032 /**
1033 * @brief Get operator information
1034 *
1035 * @param handler
1036 */
NetworkOperatorTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1037 void TelRilTest::NetworkOperatorTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1038 {
1039 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_OPERATOR);
1040 auto event = AppExecFwk::InnerEvent::Get(eventId);
1041 if (event != nullptr && telRilManager_ != nullptr) {
1042 event->SetOwner(handler);
1043 TELEPHONY_LOGI("TelRilTest::NetworkOperatorTest -->");
1044 telRilManager_->GetOperatorInfo(slotId, event);
1045 TELEPHONY_LOGI("TelRilTest::NetworkOperatorTest --> finished");
1046 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1047 ASSERT_TRUE(syncResult);
1048 }
1049 }
1050
1051 /**
1052 * @brief Send SMS
1053 *
1054 * @param handler
1055 */
SendRilCmSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1056 void TelRilTest::SendRilCmSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1057 {
1058 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SEND_SMS);
1059 auto event = AppExecFwk::InnerEvent::Get(eventId);
1060 if (event != nullptr && telRilManager_ != nullptr) {
1061 event->SetOwner(handler);
1062 TELEPHONY_LOGI("TelRilTest::SendRilCmSmsTest -->");
1063 telRilManager_->SendGsmSms(slotId, TEST_SMSC_PDU, TEST_PDU, event);
1064 TELEPHONY_LOGI("TelRilTest::SendRilCmSmsTest --> finished");
1065 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1066 ASSERT_TRUE(syncResult);
1067 }
1068 }
1069
1070 /**
1071 * @brief Storage SMS
1072 *
1073 * @param handler
1074 */
StorageRilCmSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1075 void TelRilTest::StorageRilCmSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1076 {
1077 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_STORAGE_SMS);
1078 auto event = AppExecFwk::InnerEvent::Get(eventId);
1079 SimMessageParam simMessage;
1080 simMessage.status = 0;
1081 simMessage.gsmIndex = 0;
1082 simMessage.pdu = GTEST_STRING;
1083 simMessage.smscPdu = GTEST_STRING;
1084 if (event != nullptr && telRilManager_ != nullptr) {
1085 event->SetOwner(handler);
1086 TELEPHONY_LOGI("TelRilTest::StorageRilCmSmsTest -->");
1087 telRilManager_->AddSimMessage(slotId, simMessage, event);
1088 TELEPHONY_LOGI("TelRilTest::StorageRilCmSmsTest --> finished");
1089 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1090 ASSERT_TRUE(syncResult);
1091 }
1092 }
1093
1094 /**
1095 * @brief Delete SMS
1096 *
1097 * @param handler
1098 */
DeleteRilCmSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1099 void TelRilTest::DeleteRilCmSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1100 {
1101 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_DELETE_SMS);
1102 auto event = AppExecFwk::InnerEvent::Get(eventId);
1103 int32_t gsmIndex = 0;
1104 if (event != nullptr && telRilManager_ != nullptr) {
1105 event->SetOwner(handler);
1106 TELEPHONY_LOGI("TelRilTest::DeleteRilCmSmsTest -->");
1107 telRilManager_->DelSimMessage(slotId, gsmIndex, event);
1108 TELEPHONY_LOGI("TelRilTest::DeleteRilCmSmsTest --> finished");
1109 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1110 ASSERT_TRUE(syncResult);
1111 }
1112 }
1113
1114 /**
1115 * @brief Update SMS
1116 *
1117 * @param handler
1118 */
UpdateRilCmSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1119 void TelRilTest::UpdateRilCmSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1120 {
1121 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_UPDATE_SMS);
1122 auto event = AppExecFwk::InnerEvent::Get(eventId);
1123 if (event != nullptr && telRilManager_ != nullptr) {
1124 event->SetOwner(handler);
1125 SimMessageParam simMessage;
1126 simMessage.gsmIndex = 0;
1127 simMessage.status = 0;
1128 simMessage.pdu = GTEST_STRING;
1129 simMessage.smscPdu = GTEST_STRING;
1130 TELEPHONY_LOGI("TelRilTest::UpdateRilCmSmsTest -->");
1131 telRilManager_->UpdateSimMessage(slotId, simMessage, event);
1132 TELEPHONY_LOGI("TelRilTest::UpdateRilCmSmsTest --> finished");
1133 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1134 ASSERT_TRUE(syncResult);
1135 }
1136 }
1137
1138 /**
1139 * @brief Set SMS center address
1140 *
1141 * @param handler
1142 */
SetRilCmSmsCenterAddressTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1143 void TelRilTest::SetRilCmSmsCenterAddressTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1144 {
1145 int32_t eventIdGetSmsc = static_cast<int32_t>(RadioEvent::RADIO_GET_SMS_CENTER_ADDRESS);
1146 int32_t eventIdSetSmsc = static_cast<int32_t>(RadioEvent::RADIO_SET_SMS_CENTER_ADDRESS);
1147 auto eventGetSmsc = AppExecFwk::InnerEvent::Get(eventIdGetSmsc);
1148 auto eventSetSmsc = AppExecFwk::InnerEvent::Get(eventIdSetSmsc);
1149 if (eventGetSmsc != nullptr && eventSetSmsc != nullptr && telRilManager_ != nullptr) {
1150 // get smsc first
1151 eventGetSmsc->SetOwner(handler);
1152 TELEPHONY_LOGI("TelRilTest::GetRilCmSmsCenterAddressTest -->");
1153 telRilManager_->GetSmscAddr(slotId, eventGetSmsc);
1154 TELEPHONY_LOGI("TelRilTest::GetRilCmSmsCenterAddressTest --> finished");
1155 bool syncResult = WaitGetResult(eventIdGetSmsc, handler, WAIT_TIME_SECOND);
1156 ASSERT_TRUE(syncResult);
1157 // then set smsc
1158 eventSetSmsc->SetOwner(handler);
1159 TELEPHONY_LOGI("TelRilTest::SetRilCmSmsCenterAddressTest -->");
1160 telRilManager_->SetSmscAddr(slotId, g_tosca, g_smscAddr, eventSetSmsc);
1161 TELEPHONY_LOGI("TelRilTest::SetRilCmSmsCenterAddressTest --> finished");
1162 syncResult = WaitGetResult(eventIdSetSmsc, handler, WAIT_TIME_SECOND);
1163 ASSERT_TRUE(syncResult);
1164 }
1165 }
1166
1167 /**
1168 * @brief Get SMS center address
1169 *
1170 * @param handler
1171 */
GetRilCmSmsCenterAddressTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1172 void TelRilTest::GetRilCmSmsCenterAddressTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1173 {
1174 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_SMS_CENTER_ADDRESS);
1175 auto event = AppExecFwk::InnerEvent::Get(eventId);
1176 if (event != nullptr && telRilManager_ != nullptr) {
1177 event->SetOwner(handler);
1178 TELEPHONY_LOGI("TelRilTest::GetRilCmSmsCenterAddressTest -->");
1179 telRilManager_->GetSmscAddr(slotId, event);
1180 TELEPHONY_LOGI("TelRilTest::GetRilCmSmsCenterAddressTest --> finished");
1181 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1182 ASSERT_TRUE(syncResult);
1183 }
1184 }
1185
1186 /**
1187 * @brief Set SMS cell broadcast
1188 *
1189 * @param handler
1190 */
SetRilCmCBConfigTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1191 void TelRilTest::SetRilCmCBConfigTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1192 {
1193 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CELL_BROADCAST);
1194 auto event = AppExecFwk::InnerEvent::Get(eventId);
1195 if (event != nullptr && telRilManager_ != nullptr) {
1196 event->SetOwner(handler);
1197 CBConfigParam cbConfig;
1198 cbConfig.mode = 0;
1199 cbConfig.idList = "0,1,5,320-478,922";
1200 cbConfig.dcsList = "0-3,5";
1201 TELEPHONY_LOGI("TelRilTest::SetRilCmCBConfigTest -->");
1202 telRilManager_->SetCBConfig(slotId, cbConfig, event);
1203 TELEPHONY_LOGI("TelRilTest::SetRilCmCBConfigTest --> finished");
1204 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1205 ASSERT_TRUE(syncResult);
1206 }
1207 }
1208
1209 /**
1210 * @brief Set CDMA SMS cell broadcast
1211 *
1212 * @param handler
1213 */
SetRilCmCdmaCBConfigTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1214 void TelRilTest::SetRilCmCdmaCBConfigTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1215 {
1216 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CDMA_CELL_BROADCAST);
1217 auto event = AppExecFwk::InnerEvent::Get(eventId);
1218 CdmaCBConfigInfoList broadcastInfoList = {};
1219 if (event != nullptr && telRilManager_ != nullptr) {
1220 event->SetOwner(handler);
1221 TELEPHONY_LOGI("TelRilTest::SetRilCmCdmaCBConfigTest -->");
1222 telRilManager_->SetCdmaCBConfig(slotId, broadcastInfoList, event);
1223 TELEPHONY_LOGI("TelRilTest::SetRilCmCdmaCBConfigTest --> finished");
1224 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1225 ASSERT_TRUE(syncResult);
1226 }
1227 }
1228
1229 /**
1230 * @brief Get SMS cell broadcast
1231 *
1232 * @param handler
1233 */
GetRilCmCBConfigTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1234 void TelRilTest::GetRilCmCBConfigTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1235 {
1236 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CELL_BROADCAST);
1237 auto event = AppExecFwk::InnerEvent::Get(eventId);
1238 if (event != nullptr && telRilManager_ != nullptr) {
1239 event->SetOwner(handler);
1240 TELEPHONY_LOGI("TelRilTest::GetRilCmCBConfigTest -->");
1241 telRilManager_->GetCBConfig(slotId, event);
1242 TELEPHONY_LOGI("TelRilTest::GetRilCmCBConfigTest --> finished");
1243 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1244 ASSERT_TRUE(syncResult);
1245 }
1246 }
1247
1248 /**
1249 * @brief Get CDMA SMS cell broadcast
1250 *
1251 * @param handler
1252 */
GetRilCmCdmaCBConfigTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1253 void TelRilTest::GetRilCmCdmaCBConfigTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1254 {
1255 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CDMA_CELL_BROADCAST);
1256 auto event = AppExecFwk::InnerEvent::Get(eventId);
1257 if (event != nullptr && telRilManager_ != nullptr) {
1258 event->SetOwner(handler);
1259 TELEPHONY_LOGI("TelRilTest::GetRilCmCdmaCBConfigTest -->");
1260 telRilManager_->GetCdmaCBConfig(slotId, event);
1261 TELEPHONY_LOGI("TelRilTest::GetRilCmCdmaCBConfigTest --> finished");
1262 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1263 ASSERT_TRUE(syncResult);
1264 }
1265 }
1266
1267 /**
1268 * @brief Send multiple SMS
1269 *
1270 * @param handler
1271 */
SmsSendSmsExpectMoreTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1272 void TelRilTest::SmsSendSmsExpectMoreTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1273 {
1274 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SEND_SMS_EXPECT_MORE);
1275 auto event = AppExecFwk::InnerEvent::Get(eventId);
1276 if (event != nullptr && telRilManager_ != nullptr) {
1277 event->SetOwner(handler);
1278 TELEPHONY_LOGI("TelRilTest::SmsSendSmsExpectMoreTest -->");
1279 telRilManager_->SendSmsMoreMode(slotId, TEST_SMSC_PDU, TEST_PDU, event);
1280 TELEPHONY_LOGI("TelRilTest::SmsSendSmsExpectMoreTest --> finished");
1281 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1282 ASSERT_TRUE(syncResult);
1283 }
1284 }
1285
1286 /**
1287 * @brief Set radio state
1288 *
1289 * @param handler
1290 */
SetRadioStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1291 void TelRilTest::SetRadioStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1292 {
1293 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_STATUS);
1294 auto event = AppExecFwk::InnerEvent::Get(eventId);
1295 if (event != nullptr && telRilManager_ != nullptr) {
1296 event->SetOwner(handler);
1297 TELEPHONY_LOGI("TelRilTest::SetRadioStateTest -->");
1298 // set radio state off
1299 telRilManager_->SetRadioState(slotId, 0, 0, event);
1300 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1301 ASSERT_TRUE(syncResult);
1302 // set radio state on
1303 telRilManager_->SetRadioState(slotId, 1, 0, event);
1304 syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1305 ASSERT_TRUE(syncResult);
1306 TELEPHONY_LOGI("TelRilTest::SetRadioStateTest --> finished");
1307 }
1308 }
1309
1310 /**
1311 * @brief Get radio state
1312 *
1313 * @param handler
1314 */
GetRadioStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1315 void TelRilTest::GetRadioStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1316 {
1317 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_STATUS);
1318 auto event = AppExecFwk::InnerEvent::Get(eventId);
1319 if (event != nullptr && telRilManager_ != nullptr) {
1320 event->SetOwner(handler);
1321 TELEPHONY_LOGI("TelRilTest::GetRadioStateTest -->");
1322 telRilManager_->GetRadioState(slotId, event);
1323 TELEPHONY_LOGI("TelRilTest::GetRadioStateTest --> finished");
1324 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1325 ASSERT_TRUE(syncResult);
1326 }
1327 }
1328
1329 /**
1330 * @brief SMS Acknowledge
1331 *
1332 * @param handler
1333 */
SmsAcknowledgeTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1334 void TelRilTest::SmsAcknowledgeTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1335 {
1336 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SEND_SMS_ACK);
1337 auto event = AppExecFwk::InnerEvent::Get(eventId);
1338 if (event != nullptr && telRilManager_ != nullptr) {
1339 event->SetOwner(handler);
1340 TELEPHONY_LOGI("TelRilTest::SmsAcknowledgeTest -->");
1341 telRilManager_->SendSmsAck(slotId, true, REASON, event);
1342 TELEPHONY_LOGI("TelRilTest::SmsAcknowledgeTest --> finished");
1343 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1344 ASSERT_TRUE(syncResult);
1345 }
1346 }
1347
1348 /**
1349 * @brief Add CDMA SMS
1350 *
1351 * @param handler
1352 */
AddRilCmCdmaSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1353 void TelRilTest::AddRilCmCdmaSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1354 {
1355 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_ADD_CDMA_SMS);
1356 auto event = AppExecFwk::InnerEvent::Get(eventId);
1357 int32_t status = 0;
1358 std::string pdu = GTEST_STRING;
1359 if (event != nullptr && telRilManager_ != nullptr) {
1360 event->SetOwner(handler);
1361 TELEPHONY_LOGI("TelRilTest::AddRilCmCdmaSmsTest -->");
1362 telRilManager_->AddCdmaSimMessage(slotId, status, pdu, event);
1363 TELEPHONY_LOGI("TelRilTest::AddRilCmCdmaSmsTest --> finished");
1364 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1365 ASSERT_TRUE(syncResult);
1366 }
1367 }
1368
1369 /**
1370 * @brief Delete CDMA SMS
1371 *
1372 * @param handler
1373 */
DelRilCmCdmaSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1374 void TelRilTest::DelRilCmCdmaSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1375 {
1376 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_DEL_CDMA_SMS);
1377 auto event = AppExecFwk::InnerEvent::Get(eventId);
1378 int32_t gsmIndex = 0;
1379 if (event != nullptr && telRilManager_ != nullptr) {
1380 event->SetOwner(handler);
1381 TELEPHONY_LOGI("TelRilTest::DelRilCmCdmaSmsTest -->");
1382 telRilManager_->DelCdmaSimMessage(slotId, gsmIndex, event);
1383 TELEPHONY_LOGI("TelRilTest::DelRilCmCdmaSmsTest --> finished");
1384 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1385 ASSERT_TRUE(syncResult);
1386 }
1387 }
1388
1389 /**
1390 * @brief Update CDMA SMS
1391 *
1392 * @param handler
1393 */
UpdateRilCmCdmaSmsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1394 void TelRilTest::UpdateRilCmCdmaSmsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1395 {
1396 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_UPDATE_CDMA_SMS);
1397 auto event = AppExecFwk::InnerEvent::Get(eventId);
1398 if (event != nullptr && telRilManager_ != nullptr) {
1399 event->SetOwner(handler);
1400 CdmaSimMessageParam cdmaSimMsg;
1401 cdmaSimMsg.cdmaIndex = 0;
1402 cdmaSimMsg.status = 0;
1403 cdmaSimMsg.pdu = GTEST_STRING;
1404 TELEPHONY_LOGI("TelRilTest::UpdateRilCmCdmaSmsTest -->");
1405 telRilManager_->UpdateCdmaSimMessage(slotId, cdmaSimMsg, event);
1406 TELEPHONY_LOGI("TelRilTest::UpdateRilCmCdmaSmsTest --> finished");
1407 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1408 ASSERT_TRUE(syncResult);
1409 }
1410 }
1411
1412 /**
1413 * @brief Set apn initialization information
1414 *
1415 * @param handler
1416 */
DataSetInitApnInfoTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1417 void TelRilTest::DataSetInitApnInfoTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1418 {
1419 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_INIT_APN_INFO);
1420 auto event = AppExecFwk::InnerEvent::Get(eventId);
1421 if (event != nullptr && telRilManager_ != nullptr) {
1422 event->SetOwner(handler);
1423 TELEPHONY_LOGI("TelRilTest::DataSetInitApnInfoTest -->");
1424 DataProfile dataProfile;
1425 dataProfile.profileId = 0;
1426 dataProfile.apn = "cmnet";
1427 dataProfile.protocol = "IPV4V6";
1428 dataProfile.verType = AUTHTYPE_1;
1429 dataProfile.userName = "";
1430 dataProfile.password = "";
1431 dataProfile.roamingProtocol = "IPV4V6";
1432 telRilManager_->SetInitApnInfo(slotId, dataProfile, event);
1433 TELEPHONY_LOGI("TelRilTest::DataSetInitApnInfoTest --> finished");
1434 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1435 ASSERT_TRUE(syncResult);
1436 }
1437 }
1438
1439 /**
1440 * @brief Set data call
1441 *
1442 * @param handler
1443 */
DataSetupDataCallTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1444 void TelRilTest::DataSetupDataCallTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1445 {
1446 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SETUP_DATA_CALL);
1447 auto event = AppExecFwk::InnerEvent::Get(eventId);
1448 if (event != nullptr && telRilManager_ != nullptr) {
1449 event->SetOwner(handler);
1450 ActivateDataParam activateData;
1451 activateData.param = 0;
1452 activateData.radioTechnology = 0;
1453 activateData.isRoaming = false;
1454 activateData.allowRoaming = true;
1455 activateData.dataProfile.profileId = 0;
1456 activateData.dataProfile.apn = "cmnet";
1457 activateData.dataProfile.protocol = "IPV4V6";
1458 activateData.dataProfile.verType = AUTHTYPE_1;
1459 activateData.dataProfile.userName = "";
1460 activateData.dataProfile.password = "";
1461 activateData.dataProfile.roamingProtocol = "IPV4V6";
1462 TELEPHONY_LOGI("TelRilTest::DataSetupDataCallTest -->");
1463 telRilManager_->ActivatePdpContext(slotId, activateData, event);
1464 TELEPHONY_LOGI("TelRilTest::DataSetupDataCallTest --> finished");
1465 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1466 ASSERT_TRUE(syncResult);
1467 }
1468 }
1469
1470 /**
1471 * @brief Disable data call
1472 *
1473 * @param handler
1474 */
DataDisableDataCallTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1475 void TelRilTest::DataDisableDataCallTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1476 {
1477 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_DEACTIVATE_DATA_CALL);
1478 auto event = AppExecFwk::InnerEvent::Get(eventId);
1479 if (event != nullptr && telRilManager_ != nullptr) {
1480 event->SetOwner(handler);
1481 TELEPHONY_LOGI("TelRilTest::DataDisableDataCallTest -->");
1482 telRilManager_->DeactivatePdpContext(slotId, CID, REASON, event);
1483 TELEPHONY_LOGI("TelRilTest::DataDisableDataCallTest --> finished");
1484 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1485 ASSERT_TRUE(syncResult);
1486 }
1487 }
1488
1489 /**
1490 * @brief Get data call list
1491 *
1492 * @param handler
1493 */
GetDataCallListTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1494 void TelRilTest::GetDataCallListTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1495 {
1496 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_DATA_CALL_LIST);
1497 auto event = AppExecFwk::InnerEvent::Get(eventId);
1498 if (event != nullptr && telRilManager_ != nullptr) {
1499 event->SetOwner(handler);
1500 TELEPHONY_LOGI("TelRilTest::GetDataCallListTest -->");
1501 sleep(WAIT_TIME_SECOND);
1502 telRilManager_->GetPdpContextList(slotId, event);
1503 TELEPHONY_LOGI("TelRilTest::GetDataCallListTest --> finished");
1504 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1505 ASSERT_TRUE(syncResult);
1506 }
1507 }
1508
SetDataPermittedTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1509 void TelRilTest::SetDataPermittedTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1510 {
1511 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_DATA_PERMITTED_TEST);
1512 auto event = AppExecFwk::InnerEvent::Get(eventId);
1513 if (event != nullptr && telRilManager_ != nullptr) {
1514 event->SetOwner(handler);
1515 TELEPHONY_LOGI("TelRilTest::SetDataPermittedTest -->");
1516 telRilManager_->SetDataPermitted(slotId, true, event);
1517 TELEPHONY_LOGI("TelRilTest::SetDataPermittedTest --> finished");
1518 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1519 ASSERT_TRUE(syncResult);
1520 }
1521 }
1522
1523 /**
1524 * @brief Get data link capability
1525 *
1526 * @param handler
1527 */
GetLinkCapabilityTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1528 void TelRilTest::GetLinkCapabilityTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1529 {
1530 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_CAPABILITY_TEST);
1531 auto event = AppExecFwk::InnerEvent::Get(eventId);
1532 if (event != nullptr && telRilManager_ != nullptr) {
1533 event->SetOwner(handler);
1534 TELEPHONY_LOGI("TelRilTest::GetLinkCapabilityTest -->");
1535 sleep(WAIT_TIME_SECOND);
1536 telRilManager_->GetLinkCapability(slotId, event);
1537 TELEPHONY_LOGI("TelRilTest::GetLinkCapabilityTest --> finished");
1538 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1539 ASSERT_TRUE(syncResult);
1540 }
1541 }
1542
1543 /**
1544 * @brief Clean all data connections
1545 *
1546 * @param slotId Indicates the card slot index number
1547 * @param handler Indicates the event handler ptr
1548 */
CleanAllConnectionsTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1549 void TelRilTest::CleanAllConnectionsTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1550 {
1551 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_CLEAN_ALL_DATA_CONNECTIONS_TEST);
1552 auto event = AppExecFwk::InnerEvent::Get(eventId);
1553 if (event != nullptr && telRilManager_ != nullptr) {
1554 event->SetOwner(handler);
1555 TELEPHONY_LOGI("TelRilTest::CleanAllConnectionsTest -->");
1556 sleep(WAIT_TIME_SECOND);
1557 telRilManager_->CleanAllConnections(slotId, event);
1558 TELEPHONY_LOGI("TelRilTest::CleanAllConnectionsTest --> finished");
1559 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1560 ASSERT_TRUE(syncResult);
1561 }
1562 }
1563
1564 /**
1565 * @brief Search for carrier information
1566 *
1567 * @param handler
1568 */
GetNetworkSearchInformationTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1569 void TelRilTest::GetNetworkSearchInformationTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1570 {
1571 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_NETWORKS_TO_USE);
1572 auto event = AppExecFwk::InnerEvent::Get(eventId);
1573 if (event != nullptr && telRilManager_ != nullptr) {
1574 event->SetOwner(handler);
1575 TELEPHONY_LOGI("TelRilTest::GetNetworkSearchInformationTest -->");
1576 telRilManager_->GetNetworkSearchInformation(slotId, event);
1577 TELEPHONY_LOGI("TelRilTest::GetNetworkSearchInformationTest --> finished");
1578 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1579 ASSERT_TRUE(syncResult);
1580 }
1581 }
1582
1583 /**
1584 * @brief Get selection mode
1585 *
1586 * @param handler
1587 */
GetNetworkSelectionModeTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1588 void TelRilTest::GetNetworkSelectionModeTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1589 {
1590 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_SELECTION_MOD_FOR_NETWORKS);
1591 auto event = AppExecFwk::InnerEvent::Get(eventId);
1592 if (event != nullptr && telRilManager_ != nullptr) {
1593 event->SetOwner(handler);
1594 TELEPHONY_LOGI("TelRilTest::GetNetworkSelectionModeTest -->");
1595 telRilManager_->GetNetworkSelectionMode(slotId, event);
1596 TELEPHONY_LOGI("TelRilTest::GetNetworkSelectionModeTest --> finished");
1597 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1598 ASSERT_TRUE(syncResult);
1599 }
1600 }
1601
1602 /**
1603 * @brief Set selection mode
1604 *
1605 * @param handler
1606 */
SetNetworkSelectionModeTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1607 void TelRilTest::SetNetworkSelectionModeTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1608 {
1609 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_MODE_AUTOMATIC_NETWORKS);
1610 auto event = AppExecFwk::InnerEvent::Get(eventId);
1611 if (event != nullptr && telRilManager_ != nullptr) {
1612 event->SetOwner(handler);
1613 TELEPHONY_LOGI("TelRilTest::SetNetworkSelectionModeTest -->");
1614 telRilManager_->SetNetworkSelectionMode(slotId, 0, "46001", event);
1615 TELEPHONY_LOGI("TelRilTest::SetNetworkSelectionModeTest --> finished");
1616 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1617 ASSERT_TRUE(syncResult);
1618 }
1619 }
1620
1621 /**
1622 * @brief Set preferred network parameters
1623 *
1624 * @param handler
1625 */
SetPreferredNetworkParaTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1626 void TelRilTest::SetPreferredNetworkParaTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1627 {
1628 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_PREFERRED_NETWORK_TYPE);
1629 auto event = AppExecFwk::InnerEvent::Get(eventId);
1630 if (event != nullptr && telRilManager_ != nullptr) {
1631 event->SetOwner(handler);
1632 int32_t netType = 0;
1633 TELEPHONY_LOGI("TelRilTest::SetPreferredNetworkParaTest -->");
1634 telRilManager_->SetPreferredNetwork(slotId, netType, event);
1635 TELEPHONY_LOGI("TelRilTest::SetPreferredNetworkParaTest --> finished");
1636 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1637 ASSERT_TRUE(syncResult);
1638 }
1639 }
1640
1641 /**
1642 * @brief Get preferred network parameters
1643 *
1644 * @param handler
1645 */
GetPreferredNetworkParaTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1646 void TelRilTest::GetPreferredNetworkParaTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1647 {
1648 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_PREFERRED_NETWORK_TYPE);
1649 auto event = AppExecFwk::InnerEvent::Get(eventId);
1650 if (event != nullptr && telRilManager_ != nullptr) {
1651 event->SetOwner(handler);
1652 TELEPHONY_LOGI("TelRilTest::GetPreferredNetworkParaTest -->");
1653 telRilManager_->GetPreferredNetwork(slotId, event);
1654 TELEPHONY_LOGI("TelRilTest::GetPreferredNetworkParaTest --> finished");
1655 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1656 ASSERT_TRUE(syncResult);
1657 }
1658 }
1659
1660 /**
1661 * @brief Get IMEI
1662 *
1663 * @param handler
1664 */
GetImeiTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1665 void TelRilTest::GetImeiTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1666 {
1667 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_IMEI);
1668 auto event = AppExecFwk::InnerEvent::Get(eventId);
1669 if (event != nullptr && telRilManager_ != nullptr) {
1670 event->SetOwner(handler);
1671 TELEPHONY_LOGI("TelRilTest::GetImeiTest -->");
1672 telRilManager_->GetImei(slotId, event);
1673 TELEPHONY_LOGI("TelRilTest::GetImeiTest --> finished");
1674 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1675 ASSERT_TRUE(syncResult);
1676 }
1677 }
1678
1679 /**
1680 * @brief Get IMEISV
1681 *
1682 * @param handler
1683 */
GetImeiSvTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1684 void TelRilTest::GetImeiSvTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1685 {
1686 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_IMEISV);
1687 auto event = AppExecFwk::InnerEvent::Get(eventId);
1688 if (event != nullptr && telRilManager_ != nullptr) {
1689 event->SetOwner(handler);
1690 TELEPHONY_LOGI("TelRilTest::GetImeisVTest -->");
1691 telRilManager_->GetImeiSv(slotId, event);
1692 TELEPHONY_LOGI("TelRilTest::GetImeiSvTest --> finished");
1693 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1694 ASSERT_TRUE(syncResult);
1695 }
1696 }
1697
1698 /**
1699 * @brief Get MEID
1700 *
1701 * @param handler
1702 */
GetMeidTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1703 void TelRilTest::GetMeidTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1704 {
1705 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_MEID);
1706 auto event = AppExecFwk::InnerEvent::Get(eventId);
1707 if (event != nullptr && telRilManager_ != nullptr) {
1708 event->SetOwner(handler);
1709 TELEPHONY_LOGI("TelRilTest::GetMeidTest -->");
1710 telRilManager_->GetMeid(slotId, event);
1711 TELEPHONY_LOGI("TelRilTest::GetMeidTest --> finished");
1712 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1713 ASSERT_TRUE(syncResult);
1714 }
1715 }
1716
1717 /**
1718 * @brief Get voice radio technology
1719 *
1720 * @param handler
1721 */
GetVoiceRadioTechnologyTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1722 void TelRilTest::GetVoiceRadioTechnologyTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1723 {
1724 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_VOICE_RADIO_INFO);
1725 auto event = AppExecFwk::InnerEvent::Get(eventId);
1726 if (event != nullptr && telRilManager_ != nullptr) {
1727 event->SetOwner(handler);
1728 TELEPHONY_LOGI("TelRilTest::GetVoiceRadioTechnologyTest -->");
1729 telRilManager_->GetVoiceRadioTechnology(slotId, event);
1730 TELEPHONY_LOGI("TelRilTest::GetVoiceRadioTechnologyTest --> finished");
1731 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1732 ASSERT_TRUE(syncResult);
1733 }
1734 }
1735
1736 /**
1737 * @brief Get physical channel config
1738 *
1739 * @param handler
1740 */
GetPhysicalChannelConfigTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1741 void TelRilTest::GetPhysicalChannelConfigTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1742 {
1743 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_PHYSICAL_CHANNEL_CONFIG);
1744 auto event = AppExecFwk::InnerEvent::Get(eventId);
1745 if (event != nullptr && telRilManager_ != nullptr) {
1746 event->SetOwner(handler);
1747 TELEPHONY_LOGI("TelRilTest::GetPhysicalChannelConfigTest -->");
1748 telRilManager_->GetPhysicalChannelConfig(slotId, event);
1749 TELEPHONY_LOGI("TelRilTest::GetPhysicalChannelConfigTest --> finished");
1750 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1751 ASSERT_TRUE(syncResult);
1752 }
1753 }
1754
1755 /**
1756 * @brief Set location updates
1757 *
1758 * @param handler
1759 */
SetLocateUpdatesTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1760 void TelRilTest::SetLocateUpdatesTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1761 {
1762 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_LOCATE_UPDATES);
1763 auto event = AppExecFwk::InnerEvent::Get(eventId);
1764 if (event != nullptr && telRilManager_ != nullptr) {
1765 event->SetOwner(handler);
1766 TELEPHONY_LOGI("TelRilTest::SetLocateUpdatesTest -->");
1767 RegNotifyMode mode = REG_NOTIFY_STAT_LAC_CELLID;
1768 telRilManager_->SetLocateUpdates(slotId, mode, event);
1769 TELEPHONY_LOGI("TelRilTest::SetLocateUpdatesTest --> finished");
1770 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1771 ASSERT_TRUE(syncResult);
1772 }
1773 }
1774
1775 /**
1776 * @brief Set notification fiter
1777 *
1778 * @param handler
1779 */
SetNotificationFilterTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1780 void TelRilTest::SetNotificationFilterTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1781 {
1782 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_NOTIFICATION_FILTER);
1783 auto event = AppExecFwk::InnerEvent::Get(eventId);
1784 if (event != nullptr && telRilManager_ != nullptr) {
1785 event->SetOwner(handler);
1786 int32_t filter = 1;
1787 TELEPHONY_LOGI("TelRilTest::SetNotificationFilterTest -->");
1788 telRilManager_->SetNotificationFilter(slotId, filter, event);
1789 TELEPHONY_LOGI("TelRilTest::SetNotificationFilterTest --> finished");
1790 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1791 ASSERT_TRUE(syncResult);
1792 }
1793 }
1794
1795 /**
1796 * @brief Set device state
1797 *
1798 * @param handler
1799 */
SetDeviceStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1800 void TelRilTest::SetDeviceStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1801 {
1802 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_DEVICE_STATE);
1803 auto event = AppExecFwk::InnerEvent::Get(eventId);
1804 if (event != nullptr && telRilManager_ != nullptr) {
1805 event->SetOwner(handler);
1806 int32_t deviceStateType = 0;
1807 bool deviceStateOn = true;
1808 TELEPHONY_LOGI("TelRilTest::SetDeviceStateTest -->");
1809 telRilManager_->SetDeviceState(slotId, deviceStateType, deviceStateOn, event);
1810 TELEPHONY_LOGI("TelRilTest::SetDeviceStateTest --> finished");
1811 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1812 ASSERT_TRUE(syncResult);
1813 }
1814 }
1815
1816 /**
1817 * @brief Get rrc conection state
1818 *
1819 * @param handler
1820 */
GetRrcConnectionStateTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1821 void TelRilTest::GetRrcConnectionStateTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1822 {
1823 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_RRC_CONNECTION_STATE);
1824 auto event = AppExecFwk::InnerEvent::Get(eventId);
1825 if (event != nullptr && telRilManager_ != nullptr) {
1826 event->SetOwner(handler);
1827 TELEPHONY_LOGI("TelRilTest::GetRrcConnectionStateTest -->");
1828 telRilManager_->GetRrcConnectionState(slotId, event);
1829 TELEPHONY_LOGI("TelRilTest::GetRrcConnectionStateTest --> finished");
1830 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1831 ASSERT_TRUE(syncResult);
1832 }
1833 }
1834
1835 /**
1836 * @brief Get nr mode
1837 *
1838 * @param handler
1839 */
GetNrOptionModeTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1840 void TelRilTest::GetNrOptionModeTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1841 {
1842 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_OPTION_MODE);
1843 auto event = AppExecFwk::InnerEvent::Get(eventId);
1844 if (event != nullptr && telRilManager_ != nullptr) {
1845 event->SetOwner(handler);
1846 TELEPHONY_LOGI("TelRilTest::GetNrOptionModeTest -->");
1847 telRilManager_->GetNrOptionMode(slotId, event);
1848 TELEPHONY_LOGI("TelRilTest::GetNrOptionModeTest --> finished");
1849 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1850 ASSERT_TRUE(syncResult);
1851 }
1852 }
1853
1854 /**
1855 * @brief Get nr mode
1856 *
1857 * @param handler
1858 */
SetNrOptionModeTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1859 void TelRilTest::SetNrOptionModeTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1860 {
1861 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_SET_NR_OPTION_MODE);
1862 auto event = AppExecFwk::InnerEvent::Get(eventId);
1863 if (event != nullptr && telRilManager_ != nullptr) {
1864 event->SetOwner(handler);
1865 TELEPHONY_LOGI("TelRilTest::SetNrOptionModeTest -->");
1866 int32_t mode = 1;
1867 telRilManager_->SetNrOptionMode(slotId, mode, event);
1868 TELEPHONY_LOGI("TelRilTest::SetNrOptionModeTest --> finished");
1869 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1870 ASSERT_TRUE(syncResult);
1871 }
1872 }
1873
1874 /**
1875 * @brief Get NR ssb id Information
1876 *
1877 * @param handler
1878 */
GetNrSsbIdTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1879 void TelRilTest::GetNrSsbIdTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1880 {
1881 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_NR_SSBID_INFO);
1882 auto event = AppExecFwk::InnerEvent::Get(eventId);
1883 if (event != nullptr && telRilManager_ != nullptr) {
1884 event->SetOwner(handler);
1885 TELEPHONY_LOGI("TelRilTest::GetNrSsbIdTest -->");
1886 telRilManager_->GetNrSsbId(slotId, event);
1887 TELEPHONY_LOGI("TelRilTest::GetNrSsbIdTest --> finished");
1888 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1889 ASSERT_TRUE(syncResult);
1890 }
1891 }
1892
1893 /**
1894 * @brief Get cellinfo list
1895 *
1896 * @param handler
1897 */
GetCellInfoListTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1898 void TelRilTest::GetCellInfoListTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1899 {
1900 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_GET_CELL_INFO_LIST_TYPE);
1901 auto event = AppExecFwk::InnerEvent::Get(eventId);
1902 if (event != nullptr && telRilManager_ != nullptr) {
1903 event->SetOwner(handler);
1904 TELEPHONY_LOGI("TelRilTest::GetCellInfoListTest -->");
1905 telRilManager_->GetCellInfoList(slotId, event);
1906 TELEPHONY_LOGI("TelRilTest::GetCellInfoListTest --> finished");
1907 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1908 ASSERT_TRUE(syncResult);
1909 }
1910 }
1911
1912 /**
1913 * @brief Call merge
1914 *
1915 * @param handler
1916 */
CallJoinTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1917 void TelRilTest::CallJoinTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1918 {
1919 /**
1920 * call type
1921 * 0: Voice call
1922 * 1: Video call: send one-way video
1923 * 2: Video call: two-way voice
1924 * 3: Video call: two-way video, two-way voice
1925 */
1926 int32_t callType = 0;
1927 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_JOIN_CALL);
1928 auto event = AppExecFwk::InnerEvent::Get(eventId);
1929 if (event != nullptr && telRilManager_ != nullptr) {
1930 event->SetOwner(handler);
1931 TELEPHONY_LOGI("TelRilTest::CallJoinTest -->");
1932 telRilManager_->CombineConference(slotId, callType, event);
1933 TELEPHONY_LOGI("TelRilTest::CallJoinTest --> finished");
1934 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1935 ASSERT_TRUE(syncResult);
1936 }
1937 }
1938
1939 /**
1940 * @brief Call separation
1941 *
1942 * @param handler
1943 */
CallSplitTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1944 void TelRilTest::CallSplitTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1945 {
1946 int32_t callIndex = 1;
1947 /**
1948 * call type
1949 * 0: Voice call
1950 * 1: Video call: send one-way video
1951 * 2: Video call: two-way voice
1952 * 3: Video call: two-way video, two-way voice
1953 */
1954 int32_t callType = 0;
1955 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SPLIT_CALL);
1956 auto event = AppExecFwk::InnerEvent::Get(eventId);
1957 if (event != nullptr && telRilManager_ != nullptr) {
1958 event->SetOwner(handler);
1959 TELEPHONY_LOGI("TelRilTest::CallSplitTest -->");
1960 telRilManager_->SeparateConference(slotId, callIndex, callType, event);
1961 TELEPHONY_LOGI("TelRilTest::CallSplitTest --> finished");
1962 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1963 ASSERT_TRUE(syncResult);
1964 }
1965 }
1966
1967 /**
1968 * @brief Get call forwarding
1969 *
1970 * @param handler
1971 */
GetCallForwardTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1972 void TelRilTest::GetCallForwardTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1973 {
1974 int32_t reason = 0;
1975 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CALL_FORWARD);
1976 auto event = AppExecFwk::InnerEvent::Get(eventId);
1977 if (event != nullptr && telRilManager_ != nullptr) {
1978 event->SetOwner(handler);
1979 TELEPHONY_LOGI("TelRilTest::GetCallForwardTest -->");
1980 telRilManager_->GetCallTransferInfo(slotId, reason, event);
1981 TELEPHONY_LOGI("TelRilTest::GetCallForwardTest --> finished");
1982 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
1983 ASSERT_TRUE(syncResult);
1984 }
1985 }
1986
1987 /**
1988 * @brief Set call forwarding
1989 *
1990 * @param handler
1991 */
SetCallForwardTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)1992 void TelRilTest::SetCallForwardTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
1993 {
1994 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SPLIT_CALL);
1995 auto event = AppExecFwk::InnerEvent::Get(eventId);
1996 if (event != nullptr && telRilManager_ != nullptr) {
1997 event->SetOwner(handler);
1998 CallTransferParam callTransfer;
1999 callTransfer.mode = 0;
2000 callTransfer.reason = 0;
2001 callTransfer.classx = 0;
2002 callTransfer.number = GTEST_STRING;
2003 TELEPHONY_LOGI("TelRilTest::SetCallForwardTest -->");
2004 telRilManager_->SetCallTransferInfo(slotId, callTransfer, event);
2005 TELEPHONY_LOGI("TelRilTest::SetCallForwardTest --> finished");
2006 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2007 ASSERT_TRUE(syncResult);
2008 }
2009 }
2010
2011 /**
2012 * @brief Get Calling line Identification Presentation Supplementary Service
2013 *
2014 * @param handler
2015 */
GetClipTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2016 void TelRilTest::GetClipTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2017 {
2018 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CALL_CLIP);
2019 auto event = AppExecFwk::InnerEvent::Get(eventId);
2020 if (event != nullptr && telRilManager_ != nullptr) {
2021 event->SetOwner(handler);
2022 TELEPHONY_LOGI("TelRilTest::GetClipTest -->");
2023 telRilManager_->GetClip(slotId, event);
2024 TELEPHONY_LOGI("TelRilTest::GetClipTest --> finished");
2025 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2026 ASSERT_TRUE(syncResult);
2027 }
2028 }
2029
2030 /**
2031 * @brief Set Calling line Identification Presentation Supplementary Service
2032 *
2033 * @param handler
2034 */
SetClipTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2035 void TelRilTest::SetClipTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2036 {
2037 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CALL_CLIP);
2038 auto event = AppExecFwk::InnerEvent::Get(eventId);
2039 if (event != nullptr && telRilManager_ != nullptr) {
2040 int32_t action = 0;
2041 event->SetOwner(handler);
2042 TELEPHONY_LOGI("TelRilTest::SetClipTest -->");
2043 telRilManager_->SetClip(slotId, action, event);
2044 TELEPHONY_LOGI("TelRilTest::SetClipTest --> finished");
2045 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2046 ASSERT_TRUE(syncResult);
2047 }
2048 }
2049
2050 /**
2051 * @brief Get call barring
2052 *
2053 * @param handler
2054 */
GetCallRestrictionTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2055 void TelRilTest::GetCallRestrictionTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2056 {
2057 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CALL_RESTRICTION);
2058 auto event = AppExecFwk::InnerEvent::Get(eventId);
2059 if (event != nullptr && telRilManager_ != nullptr) {
2060 event->SetOwner(handler);
2061 TELEPHONY_LOGI("TelRilTest::GetCallRestrictionTest -->");
2062 telRilManager_->GetCallRestriction(slotId, "AI", event);
2063 TELEPHONY_LOGI("TelRilTest::GetCallRestrictionTest --> finished");
2064 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2065 ASSERT_TRUE(syncResult);
2066 }
2067 }
2068
2069 /**
2070 * @brief Set call barring
2071 *
2072 * @param handler
2073 */
SetCallRestrictionTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2074 void TelRilTest::SetCallRestrictionTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2075 {
2076 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CALL_RESTRICTION);
2077 auto event = AppExecFwk::InnerEvent::Get(eventId);
2078 if (event != nullptr && telRilManager_ != nullptr) {
2079 event->SetOwner(handler);
2080 CallRestrictionParam callRestriction;
2081 callRestriction.mode = 0;
2082 callRestriction.fac = GTEST_STRING;
2083 if (strcpy_s(callRestriction.password, strlen(GTEST_STRING.c_str()) + 1, GTEST_STRING.c_str()) != EOK) {
2084 TELEPHONY_LOGE("TelRilTest::SetCallRestrictionTest stop by strcpy_s fail.");
2085 return;
2086 }
2087 TELEPHONY_LOGI("TelRilTest::SetCallRestrictionTest -->");
2088 telRilManager_->SetCallRestriction(slotId, callRestriction, event);
2089 TELEPHONY_LOGI("TelRilTest::SetCallRestrictionTest --> finished");
2090 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2091 ASSERT_TRUE(syncResult);
2092 }
2093 }
2094
2095 /**
2096 * @brief Set call barring password
2097 *
2098 * @param handler
2099 */
SetBarringPasswordTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2100 void TelRilTest::SetBarringPasswordTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2101 {
2102 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CALL_RESTRICTION_PWD);
2103 auto event = AppExecFwk::InnerEvent::Get(eventId, slotId);
2104 if (event != nullptr && telRilManager_ != nullptr) {
2105 event->SetOwner(handler);
2106 std::string fac = GTEST_STRING;
2107 char oldPassword[MAX_BUF_SIZE + 1] = "oldPWD";
2108 char newPassword[MAX_BUF_SIZE + 1] = "newPWD";
2109 TELEPHONY_LOGI("TelRilTest::SetBarringPasswordTest -->");
2110 telRilManager_->SetBarringPassword(slotId, newPassword, oldPassword, fac, event);
2111 TELEPHONY_LOGI("TelRilTest::SetBarringPasswordTest --> finished");
2112 (void)memset_s(oldPassword, sizeof(oldPassword), 0, sizeof(oldPassword));
2113 (void)memset_s(newPassword, sizeof(newPassword), 0, sizeof(newPassword));
2114 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2115 ASSERT_TRUE(syncResult);
2116 }
2117 }
2118
2119 /**
2120 * @brief Send DTMF
2121 *
2122 * @param handler
2123 */
SendDtmfTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2124 void TelRilTest::SendDtmfTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2125 {
2126 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SEND_DTMF);
2127 auto event = AppExecFwk::InnerEvent::Get(eventId);
2128 if (event != nullptr && telRilManager_ != nullptr) {
2129 event->SetOwner(handler);
2130 TELEPHONY_LOGI("TelRilTest::SendDtmfTest -->");
2131 TELEPHONY_LOGI("TelRilTest::SendDtmfTest --> finished");
2132 }
2133 }
2134
2135 /**
2136 * @brief Start DTMF
2137 *
2138 * @param handler
2139 */
StartDtmfTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2140 void TelRilTest::StartDtmfTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2141 {
2142 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_START_DTMF);
2143 auto event = AppExecFwk::InnerEvent::Get(eventId);
2144 if (event != nullptr && telRilManager_ != nullptr) {
2145 event->SetOwner(handler);
2146 TELEPHONY_LOGI("TelRilTest::StartDtmfTest -->");
2147 TELEPHONY_LOGI("TelRilTest::StartDtmfTest --> finished");
2148 }
2149 }
2150
2151 /**
2152 * @brief Stop DTMF
2153 *
2154 * @param handler
2155 */
StopDtmfTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2156 void TelRilTest::StopDtmfTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2157 {
2158 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_STOP_DTMF);
2159 auto event = AppExecFwk::InnerEvent::Get(eventId);
2160 if (event != nullptr && telRilManager_ != nullptr) {
2161 event->SetOwner(handler);
2162 TELEPHONY_LOGI("TelRilTest::StopDtmfTest -->");
2163 TELEPHONY_LOGI("TelRilTest::StopDtmfTest --> finished");
2164 }
2165 }
2166
2167 /**
2168 * @brief Set USSD
2169 *
2170 * @param handler
2171 */
SetUssdTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2172 void TelRilTest::SetUssdTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2173 {
2174 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_USSD);
2175 auto event = AppExecFwk::InnerEvent::Get(eventId);
2176 if (event != nullptr && telRilManager_ != nullptr) {
2177 event->SetOwner(handler);
2178 TELEPHONY_LOGI("TelRilTest::SetUssdTest -->");
2179 telRilManager_->SetUssd(slotId, "12345678", event);
2180 TELEPHONY_LOGI("TelRilTest::SetUssdTest --> finished");
2181 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2182 ASSERT_TRUE(syncResult);
2183 }
2184 }
2185
2186 /**
2187 * @brief Get USSD
2188 *
2189 * @param handler
2190 */
GetUssdTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2191 void TelRilTest::GetUssdTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2192 {
2193 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_USSD);
2194 auto event = AppExecFwk::InnerEvent::Get(eventId);
2195 if (event != nullptr && telRilManager_ != nullptr) {
2196 event->SetOwner(handler);
2197 TELEPHONY_LOGI("TelRilTest::GetUssdTest -->");
2198 telRilManager_->GetUssd(slotId, event);
2199 TELEPHONY_LOGI("TelRilTest::GetUssdTest --> finished");
2200 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2201 ASSERT_TRUE(syncResult);
2202 }
2203 }
2204
2205 /**
2206 * @brief Set call mute
2207 *
2208 * @param handler
2209 */
SetMuteTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2210 void TelRilTest::SetMuteTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2211 {
2212 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_CMUT);
2213 auto event = AppExecFwk::InnerEvent::Get(eventId);
2214 if (event != nullptr && telRilManager_ != nullptr) {
2215 event->SetOwner(handler);
2216 TELEPHONY_LOGI("TelRilTest::SetMuteTest -->");
2217 telRilManager_->SetMute(slotId, 1, event);
2218 TELEPHONY_LOGI("TelRilTest::SetMuteTest --> finished");
2219 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2220 ASSERT_TRUE(syncResult);
2221 }
2222 }
2223
2224 /**
2225 * @brief Get call mute
2226 *
2227 * @param handler
2228 */
GetMuteTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2229 void TelRilTest::GetMuteTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2230 {
2231 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_CMUT);
2232 auto event = AppExecFwk::InnerEvent::Get(eventId);
2233 if (event != nullptr && telRilManager_ != nullptr) {
2234 event->SetOwner(handler);
2235 TELEPHONY_LOGI("TelRilTest::GetMuteTest -->");
2236 telRilManager_->GetMute(slotId, event);
2237 TELEPHONY_LOGI("TelRilTest::GetMuteTest --> finished");
2238 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2239 ASSERT_TRUE(syncResult);
2240 }
2241 }
2242
2243 /**
2244 * @brief Get emergency call list
2245 *
2246 * @param handler
2247 */
GetEmergencyCallListTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2248 void TelRilTest::GetEmergencyCallListTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2249 {
2250 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_GET_EMERGENCY_CALL_LIST);
2251 auto event = AppExecFwk::InnerEvent::Get(eventId);
2252 if (event != nullptr && telRilManager_ != nullptr) {
2253 event->SetOwner(handler);
2254 TELEPHONY_LOGI("TelRilTest::GetEmergencyCallListTest -->");
2255 telRilManager_->GetEmergencyCallList(slotId, event);
2256 TELEPHONY_LOGI("TelRilTest::GetEmergencyCallListTest --> finished");
2257 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND_LONG);
2258 ASSERT_TRUE(syncResult);
2259 }
2260 }
2261
2262 /**
2263 * @brief Set VoNR Switch
2264 *
2265 * @param handler
2266 */
SetVoNRSwitchTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2267 void TelRilTest::SetVoNRSwitchTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2268 {
2269 int32_t eventId = static_cast<int32_t>(RadioEvent::RADIO_SET_VONR_SWITCH_STATUS);
2270 auto event = AppExecFwk::InnerEvent::Get(eventId);
2271 if (event != nullptr && telRilManager_ != nullptr) {
2272 event->SetOwner(handler);
2273 TELEPHONY_LOGI("TelRilTest::SetVoNRSwitchTest -->");
2274 telRilManager_->SetVoNRSwitch(slotId, 1, event);
2275 TELEPHONY_LOGI("TelRilTest::SetVoNRSwitchTest --> finished");
2276 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2277 ASSERT_TRUE(syncResult);
2278 }
2279 }
2280
2281 /**
2282 * @brief Setting link bandwidth reporting rules
2283 *
2284 * @param handler
2285 */
OnRequestSetLinkBandwidthReportingRuleTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2286 void TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest(int32_t slotId,
2287 std::shared_ptr<AppExecFwk::EventHandler> handler)
2288 {
2289 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_SET_LINK_BANDWIDTH_REPORTING_RULE);
2290 auto event = AppExecFwk::InnerEvent::Get(eventId);
2291 if (event != nullptr && telRilManager_ != nullptr) {
2292 event->SetOwner(handler);
2293 TELEPHONY_LOGI("TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest -->");
2294 LinkBandwidthRule rule;
2295 rule.delayMs = BANDWIDTH_HYSTERESIS_MS;
2296 rule.rat = NETWORK_TYPE_LTE;
2297 rule.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
2298 rule.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
2299 for (uint32_t i = 0; i < sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int); i++) {
2300 rule.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
2301 }
2302 for (uint32_t i = 0; i < sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int); i++) {
2303 rule.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
2304 }
2305 telRilManager_->SetLinkBandwidthReportingRule(slotId, rule, event);
2306 TELEPHONY_LOGI("TelRilTest::OnRequestSetLinkBandwidthReportingRuleTest --> finished");
2307 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2308 ASSERT_TRUE(syncResult);
2309 }
2310 }
2311
2312 /**
2313 * @brief Get link bandwidth information
2314 *
2315 * @param handler
2316 */
GetLinkBandwidthInfoTest(int32_t slotId,std::shared_ptr<AppExecFwk::EventHandler> handler)2317 void TelRilTest::GetLinkBandwidthInfoTest(int32_t slotId, std::shared_ptr<AppExecFwk::EventHandler> handler)
2318 {
2319 int32_t eventId = static_cast<int32_t>(DiffInterfaceId::TEST_RILCM_GET_LINK_BANDWIDTH_INFO);
2320 auto event = AppExecFwk::InnerEvent::Get(eventId);
2321 if (event != nullptr && telRilManager_ != nullptr) {
2322 event->SetOwner(handler);
2323 int32_t cid = CID;
2324 TELEPHONY_LOGI("TelRilTest::GetLinkBandwidthInfoTest -->");
2325 telRilManager_->GetLinkBandwidthInfo(slotId, cid, event);
2326 TELEPHONY_LOGI("TelRilTest::GetLinkBandwidthInfoTest --> finished");
2327 bool syncResult = WaitGetResult(eventId, handler, WAIT_TIME_SECOND);
2328 ASSERT_TRUE(syncResult);
2329 }
2330 }
2331
2332 /**
2333 * @brief Waiting the result
2334 * @param eventId
2335 * @param handler
2336 * @param timeOut
2337 */
WaitGetResult(int32_t eventId,std::shared_ptr<AppExecFwk::EventHandler> handler,int32_t timeOut)2338 bool TelRilTest::WaitGetResult(int32_t eventId, std::shared_ptr<AppExecFwk::EventHandler> handler, int32_t timeOut)
2339 {
2340 TelRilTest::DemoHandler *demoHandler = static_cast<TelRilTest::DemoHandler *>(handler.get());
2341 if (demoHandler == nullptr) {
2342 return false;
2343 }
2344 demoHandler->WaitFor(timeOut);
2345 bool syncResult = demoHandler->GetBoolResult(eventId);
2346 return syncResult;
2347 }
2348
NotifyAll()2349 void TelRilTest::DemoHandler::NotifyAll()
2350 {
2351 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
2352 cv_.notify_all();
2353 }
2354
WaitFor(int32_t timeoutSecond)2355 void TelRilTest::DemoHandler::WaitFor(int32_t timeoutSecond)
2356 {
2357 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
2358 cv_.wait_for(callbackLock, std::chrono::seconds(timeoutSecond));
2359 }
2360
Clean()2361 void TelRilTest::DemoHandler::Clean()
2362 {
2363 eventId_ = 0;
2364 resultInfo_ = nullptr;
2365 }
2366
GetBoolResult(int32_t eventId)2367 bool TelRilTest::DemoHandler::GetBoolResult(int32_t eventId)
2368 {
2369 bool ret = false;
2370 if (eventId_ == 0) {
2371 TELEPHONY_LOGI(
2372 "Ril interface response timeout, not implemented."
2373 "eventId: %{public}d, current eventId: %{public}d",
2374 eventId, eventId_);
2375 ret = true;
2376 Clean();
2377 return ret;
2378 }
2379 if (eventId_ != eventId) {
2380 ret = false;
2381 TELEPHONY_LOGI("GetBoolResult eventId does not match. eventId: %{public}d, current eventId: %{public}d",
2382 eventId, eventId_);
2383 Clean();
2384 return ret;
2385 }
2386 if ((resultInfo_ != nullptr) &&
2387 ((resultInfo_->error == ErrType::NONE) || (resultInfo_->error == ErrType::ERR_GENERIC_FAILURE) ||
2388 (resultInfo_->error == ErrType::ERR_INVALID_RESPONSE) ||
2389 (resultInfo_->error == ErrType::ERR_INVALID_MODEM_PARAMETER))) {
2390 ret = true;
2391 }
2392 if (resultInfo_ == nullptr) {
2393 ret = true;
2394 TELEPHONY_LOGI("GetBoolResult eventId: %{public}d", eventId_);
2395 } else {
2396 TELEPHONY_LOGI("GetBoolResult eventId: %{public}d, error: %{public}d", eventId_, (int32_t)(resultInfo_->error));
2397 }
2398 Clean();
2399 return ret;
2400 }
2401
ProcessResponseInfo(const AppExecFwk::InnerEvent::Pointer & event)2402 void TelRilTest::DemoHandler::ProcessResponseInfo(const AppExecFwk::InnerEvent::Pointer &event)
2403 {
2404 if (event != nullptr) {
2405 eventId_ = event->GetInnerEventId();
2406 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> eventId:%{public}d", eventId_);
2407 // for some SIM interfaces, response data need to be get before RadioResponseInfo
2408 switch (eventId_) {
2409 case static_cast<int32_t>(RadioEvent::RADIO_SIM_GET_IMSI): {
2410 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> RADIO_SIM_GET_IMSI");
2411 std::shared_ptr<std::string> imsi = event->GetSharedObject<std::string>();
2412 if (imsi != nullptr) {
2413 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> imsi=%{public}s", imsi->c_str());
2414 } else {
2415 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> get resultInfo_");
2416 resultInfo_ = event->GetSharedObject<RadioResponseInfo>();
2417 }
2418 break;
2419 }
2420 case static_cast<int32_t>(RadioEvent::RADIO_GET_SMS_CENTER_ADDRESS): {
2421 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> RADIO_GET_SMS_CENTER_ADDRESS");
2422 std::shared_ptr<ServiceCenterAddress> addr = event->GetSharedObject<ServiceCenterAddress>();
2423 if (addr != nullptr) {
2424 g_smscAddr = addr->address;
2425 g_tosca = addr->tosca;
2426 TELEPHONY_LOGI(
2427 "TelRilTest::DemoHandler::ProcessResponseInfo --> g_smscAddr=%{public}s,"
2428 "g_tosca=%{public}d",
2429 g_smscAddr.c_str(), g_tosca);
2430 } else {
2431 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> get resultInfo_");
2432 resultInfo_ = event->GetSharedObject<RadioResponseInfo>();
2433 }
2434 break;
2435 }
2436 default: {
2437 TELEPHONY_LOGI("TelRilTest::DemoHandler::ProcessResponseInfo --> case default");
2438 resultInfo_ = event->GetSharedObject<RadioResponseInfo>();
2439 }
2440 }
2441 }
2442 NotifyAll();
2443 }
2444
2445 /**
2446 * @brief Process event
2447 *
2448 * @param event
2449 */
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)2450 void TelRilTest::DemoHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
2451 {
2452 ProcessResponseInfo(event);
2453 }
2454
GetRandNum()2455 uint32_t TelRilTest::GetRandNum()
2456 {
2457 int32_t r = 0;
2458 int fd = open("/dev/random", O_RDONLY);
2459 if (fd > 0) {
2460 read(fd, &r, sizeof(int32_t));
2461 }
2462 close(fd);
2463 return r;
2464 }
2465
2466 /**
2467 * @brief Get random phone number
2468 *
2469 * @param length
2470 */
GetRandPhoneNum(const int len)2471 std::string TelRilTest::GetRandPhoneNum(const int len)
2472 {
2473 char c;
2474 int32_t idx;
2475 uint32_t rtv = 0;
2476 std::string str;
2477
2478 for (idx = 0; idx < len; idx++) {
2479 rtv = GetRandNum() % DECIMAL;
2480 c = static_cast<char>(rtv + '0');
2481 str.push_back(c);
2482 }
2483
2484 return str;
2485 }
2486
GetHandler(void)2487 std::shared_ptr<TelRilTest::DemoHandler> TelRilTest::GetHandler(void)
2488 {
2489 std::shared_ptr<AppExecFwk::EventRunner> eventRunner;
2490 std::shared_ptr<TelRilTest::DemoHandler> demohandler;
2491 if (telRilManager_ == nullptr) {
2492 TELEPHONY_LOGE("ERROR : make_shared<ITelRilManager>(telRilManager) --> nullptr !!!");
2493 return NULL;
2494 }
2495 eventRunner = AppExecFwk::EventRunner::Create("DemoHandler");
2496 if (eventRunner == nullptr) {
2497 TELEPHONY_LOGE("ERROR : AppExecFwk::EventRunner::Create(\"DemoHandler\") --> nullptr !!!");
2498 return NULL;
2499 }
2500 demohandler = std::make_shared<TelRilTest::DemoHandler>(eventRunner);
2501 if (demohandler == nullptr) {
2502 TELEPHONY_LOGE("ERROR : make_shared<TelRilTest::DemoHandler>(runner) --> nullptr !!!");
2503 return NULL;
2504 }
2505 eventRunner->Run();
2506
2507 return demohandler;
2508 }
2509 } // namespace Telephony
2510 } // namespace OHOS
2511