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