1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cmath"
17 #include "condition_variable"
18 #include "cstdio"
19 #include "gtest/gtest.h"
20 #include "hdf_base.h"
21 #include "hdf_log.h"
22 #include "map"
23 #include "mutex"
24 #include "securec.h"
25 #include "stdlib.h"
26 #include "unistd.h"
27 #include "v1_5/iril.h"
28
29 using namespace OHOS::HDI::Ril::V1_5;
30 using namespace testing::ext;
31
32 enum class HdiId {
33 HREQ_NONE = -1,
34 HREQ_CALL_BASE = 0,
35 HREQ_CALL_GET_CALL_LIST,
36 HREQ_CALL_DIAL,
37 HREQ_CALL_HANGUP,
38 HREQ_CALL_REJECT,
39 HREQ_CALL_ANSWER,
40 HREQ_CALL_HOLD_CALL, // call hold value 6
41 HREQ_CALL_UNHOLD_CALL, // call active value 6
42 HREQ_CALL_SWITCH_CALL,
43 HREQ_CALL_COMBINE_CONFERENCE,
44 HREQ_CALL_SEPARATE_CONFERENCE, // Keep all other calls except the xth call
45 HREQ_CALL_CALL_SUPPLEMENT,
46 HREQ_CALL_SEND_DTMF,
47 HREQ_CALL_START_DTMF,
48 HREQ_CALL_STOP_DTMF,
49 HREQ_CALL_SET_CLIP,
50 HREQ_CALL_GET_CLIP,
51 HREQ_CALL_GET_CALL_WAITING,
52 HREQ_CALL_SET_CALL_WAITING,
53 HREQ_CALL_GET_CALL_RESTRICTION,
54 HREQ_CALL_SET_CALL_RESTRICTION,
55 HREQ_CALL_GET_CALL_TRANSFER_INFO,
56 HREQ_CALL_SET_CALL_TRANSFER_INFO,
57 HREQ_CALL_GET_CLIR,
58 HREQ_CALL_SET_CLIR,
59 HREQ_CALL_GET_CALL_PREFERENCE,
60 HREQ_CALL_SET_CALL_PREFERENCE,
61 HREQ_CALL_SET_USSD,
62 HREQ_CALL_GET_USSD,
63 HREQ_CALL_SET_MUTE,
64 HREQ_CALL_GET_MUTE,
65 HREQ_CALL_GET_EMERGENCY_LIST,
66 HREQ_CALL_SET_EMERGENCY_LIST,
67 HREQ_CALL_GET_FAIL_REASON,
68 HREQ_CALL_SET_BARRING_PASSWORD,
69 HREQ_CALL_CLOSE_UNFINISHED_USSD,
70 HREQ_SET_VONR_SWITCH,
71
72 HREQ_SMS_BASE = 100,
73 HREQ_SMS_SEND_GSM_SMS,
74 HREQ_SMS_SEND_CDMA_SMS,
75 HREQ_SMS_ADD_SIM_MESSAGE,
76 HREQ_SMS_DEL_SIM_MESSAGE,
77 HREQ_SMS_UPDATE_SIM_MESSAGE,
78 HREQ_SMS_SEND_SMS_MORE_MODE,
79 HREQ_SMS_SEND_SMS_ACK,
80 HREQ_SMS_SET_SMSC_ADDR,
81 HREQ_SMS_GET_SMSC_ADDR,
82 HREQ_SMS_SET_CB_CONFIG,
83 HREQ_SMS_GET_CB_CONFIG,
84 HREQ_SMS_GET_CDMA_CB_CONFIG,
85 HREQ_SMS_SET_CDMA_CB_CONFIG,
86 HREQ_SMS_ADD_CDMA_SIM_MESSAGE,
87 HREQ_SMS_DEL_CDMA_SIM_MESSAGE,
88 HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE,
89
90 HREQ_SIM_BASE = 200,
91 HREQ_SIM_GET_SIM_STATUS,
92 HREQ_SIM_GET_IMSI,
93 HREQ_SIM_GET_SIM_IO,
94 HREQ_SIM_GET_SIM_LOCK_STATUS,
95 HREQ_SIM_SET_SIM_LOCK,
96 HREQ_SIM_CHANGE_SIM_PASSWORD,
97 HREQ_SIM_UNLOCK_PIN,
98 HREQ_SIM_UNLOCK_PUK,
99 HREQ_SIM_GET_SIM_PIN_INPUT_TIMES,
100 HREQ_SIM_UNLOCK_PIN2,
101 HREQ_SIM_UNLOCK_PUK2,
102 HREQ_SIM_GET_SIM_PIN2_INPUT_TIMES,
103 HREQ_SIM_SET_ACTIVE_SIM,
104 HREQ_SIM_RADIO_PROTOCOL,
105 HREQ_SIM_STK_SEND_TERMINAL_RESPONSE,
106 HREQ_SIM_STK_SEND_ENVELOPE,
107 HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT,
108 HREQ_SIM_STK_IS_READY,
109 HREQ_SIM_OPEN_LOGICAL_CHANNEL,
110 HREQ_SIM_CLOSE_LOGICAL_CHANNEL,
111 HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL,
112 HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL,
113 HREQ_SIM_AUTHENTICATION,
114 HREQ_SIM_UNLOCK_SIM_LOCK,
115 HREQ_SIM_SEND_NCFG_OPER_INFO,
116 HREQ_SIM_GET_PRIMARY_SLOT,
117 HREQ_SIM_SET_PRIMARY_SLOT,
118
119 HREQ_DATA_BASE = 300,
120 HREQ_DATA_SET_INIT_APN_INFO,
121 HREQ_DATA_DEACTIVATE_PDP_CONTEXT,
122 HREQ_DATA_ACTIVATE_PDP_CONTEXT,
123 HREQ_DATA_GET_PDP_CONTEXT_LIST,
124 HREQ_DATA_GET_LINK_BANDWIDTH_INFO,
125 HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE,
126 HREQ_DATA_SET_DATA_PROFILE_INFO,
127 HREQ_DATA_SEND_DATA_PERFORMANCE_MODE,
128 HREQ_DATA_SEND_DATA_SLEEP_MODE,
129 HREQ_DATA_SET_DATA_PERMITTED,
130 HREQ_DATA_GET_LINK_CAPABILITY,
131 HREQ_DATA_CLEAN_ALL_CONNECTIONS,
132 HREQ_DATA_SEND_UEPOLICY_DECODE_RESULT,
133 HREQ_DATA_SEND_UE_SECTION_IDENTIFIER,
134 HREQ_DATA_SEND_IMS_RSD_LIST,
135 HREQ_DATA_SYNC_ALLOWED_NSSAI_WITH_MODEM,
136 HREQ_DATA_SYNC_EHPLMN_WITH_MODEM,
137
138 HREQ_NETWORK_BASE = 400,
139 HREQ_NETWORK_GET_SIGNAL_STRENGTH,
140 HREQ_NETWORK_GET_CS_REG_STATUS,
141 HREQ_NETWORK_GET_PS_REG_STATUS,
142 HREQ_NETWORK_GET_OPERATOR_INFO,
143 HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION,
144 HREQ_NETWORK_GET_NETWORK_SELECTION_MODE,
145 HREQ_NETWORK_SET_NETWORK_SELECTION_MODE,
146 HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST,
147 HREQ_NETWORK_GET_CURRENT_CELL_INFO,
148 HREQ_NETWORK_SET_PREFERRED_NETWORK,
149 HREQ_NETWORK_GET_PREFERRED_NETWORK,
150 HREQ_NETWORK_GET_RADIO_CAPABILITY,
151 HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG,
152 HREQ_NETWORK_SET_LOCATE_UPDATES,
153 HREQ_NETWORK_SET_NOTIFICATION_FILTER,
154 HREQ_NETWORK_SET_DEVICE_STATE,
155 HREQ_NETWORK_GET_RRC_CONNECTION_STATE,
156 HREQ_NETWORK_SET_NR_OPTION_MODE,
157 HREQ_NETWORK_GET_NR_OPTION_MODE,
158 HREQ_NETWORK_GET_NR_SSBID_INFO,
159
160 HREQ_COMMON_BASE = 500,
161 HREQ_MODEM_SHUT_DOWN,
162 HREQ_MODEM_SET_RADIO_STATUS,
163 HREQ_MODEM_GET_RADIO_STATUS,
164 HREQ_MODEM_GET_IMEI,
165 HREQ_MODEM_GET_IMEISV,
166 HREQ_MODEM_GET_MEID,
167 HREQ_MODEM_GET_BASEBAND_VERSION,
168 HREQ_MODEM_GET_VOICE_RADIO,
169 HREQ_MODEM_EXIT = 1000
170 };
171
172 enum class DeviceStateType { POWER_SAVE_MODE, CHARGING_STATE, LOW_DATA_STATE };
173
174 enum class NrMode { NR_MODE_UNKNOWN, NR_MODE_NSA_ONLY, NR_MODE_SA_ONLY, NR_MODE_NSA_AND_SA };
175
176 enum class NotificationFilter {
177 NOTIFICATION_FILTER_ALL = -1,
178 NOTIFICATION_FILTER_NONE = 0,
179 NOTIFICATION_FILTER_SIGNAL_STRENGTH = 1,
180 NOTIFICATION_FILTER_NETWORK_STATE = 2,
181 NOTIFICATION_FILTER_DATA_CALL = 4,
182 NOTIFICATION_FILTER_LINK_CAPACITY = 8,
183 NOTIFICATION_FILTER_PHYSICAL_CHANNEL_CONFIG = 16
184 };
185
186 enum class RatType {
187 NETWORK_TYPE_UNKNOWN = 0,
188 NETWORK_TYPE_GSM,
189 NETWORK_TYPE_CDMA,
190 NETWORK_TYPE_WCDMA,
191 NETWORK_TYPE_TDSCDMA,
192 NETWORK_TYPE_LTE,
193 NETWORK_TYPE_NR
194 };
195
196 enum class SelectionMode { MODE_TYPE_UNKNOWN = -1, MODE_TYPE_AUTO = 0, MODE_TYPE_MANUAL = 1 };
197
198 enum class PreferredNetworkMode {
199 CORE_NETWORK_MODE_AUTO = 0,
200 CORE_NETWORK_MODE_GSM = 1,
201 CORE_NETWORK_MODE_WCDMA = 2,
202 CORE_NETWORK_MODE_LTE = 3,
203 CORE_NETWORK_MODE_LTE_WCDMA = 4,
204 CORE_NETWORK_MODE_LTE_WCDMA_GSM = 5,
205 CORE_NETWORK_MODE_WCDMA_GSM = 6,
206 CORE_NETWORK_MODE_CDMA = 7,
207 CORE_NETWORK_MODE_EVDO = 8,
208 CORE_NETWORK_MODE_EVDO_CDMA = 9,
209 CORE_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA = 10,
210 CORE_NETWORK_MODE_LTE_EVDO_CDMA = 11,
211 CORE_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA = 12,
212 CORE_NETWORK_MODE_TDSCDMA = 13,
213 CORE_NETWORK_MODE_TDSCDMA_GSM = 14,
214 CORE_NETWORK_MODE_TDSCDMA_WCDMA = 15,
215 CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM = 16,
216 CORE_NETWORK_MODE_LTE_TDSCDMA = 17,
217 CORE_NETWORK_MODE_LTE_TDSCDMA_GSM = 18,
218 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA = 19,
219 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM = 20,
220 CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 21,
221 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 22,
222 CORE_NETWORK_MODE_NR = 31,
223 CORE_NETWORK_MODE_NR_LTE = 32,
224 CORE_NETWORK_MODE_NR_LTE_WCDMA = 33,
225 CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM = 34,
226 CORE_NETWORK_MODE_NR_LTE_EVDO_CDMA = 35,
227 CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA = 36,
228 CORE_NETWORK_MODE_NR_LTE_TDSCDMA = 37,
229 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_GSM = 38,
230 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA = 39,
231 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM = 40,
232 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 41,
233 CORE_NETWORK_MODE_MAX_VALUE = 99,
234 };
235
236 enum class SimMessageStatus {
237 SIM_MESSAGE_STATUS_UNREAD = 0,
238 SIM_MESSAGE_STATUS_READ = 1,
239 SIM_MESSAGE_STATUS_UNSENT = 2,
240 SIM_MESSAGE_STATUS_SENT = 3,
241 };
242
243 class RilCallback : public OHOS::HDI::Ril::V1_5::IRilCallback {
244 public:
245 void NotifyAll();
246 void WaitFor(int32_t timeoutSecond);
247 bool GetBoolResult(HdiId hdiId_);
248 void Clean();
249
250 // Call
251 int32_t CallStateUpdated(const RilRadioResponseInfo &responseInfo) override;
252 int32_t CallRingbackVoiceNotice(
253 const RilRadioResponseInfo &responseInfo, const RingbackVoice &ringbackVoice) override;
254 int32_t CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus) override;
255 int32_t CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo) override;
256 int32_t CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo) override;
257 int32_t CallEmergencyNotice(
258 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList) override;
259 int32_t CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo) override;
260 int32_t SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo) override;
261 int32_t GetEmergencyCallListResponse(
262 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList) override;
263 int32_t GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList) override;
264 int32_t DialResponse(const RilRadioResponseInfo &responseInfo) override;
265 int32_t HangupResponse(const RilRadioResponseInfo &responseInfo) override;
266 int32_t RejectResponse(const RilRadioResponseInfo &responseInfo) override;
267 int32_t AnswerResponse(const RilRadioResponseInfo &responseInfo) override;
268 int32_t HoldCallResponse(const RilRadioResponseInfo &responseInfo) override;
269 int32_t UnHoldCallResponse(const RilRadioResponseInfo &responseInfo) override;
270 int32_t SwitchCallResponse(const RilRadioResponseInfo &responseInfo) override;
271 int32_t GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult) override;
272 int32_t SetClipResponse(const RilRadioResponseInfo &responseInfo) override;
273 int32_t CombineConferenceResponse(const RilRadioResponseInfo &responseInfo) override;
274 int32_t SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo) override;
275 int32_t CallSupplementResponse(const RilRadioResponseInfo &responseInfo) override;
276 int32_t GetCallWaitingResponse(
277 const RilRadioResponseInfo &responseInfo, const CallWaitResult &callWaitResult) override;
278 int32_t SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo) override;
279 int32_t GetCallTransferInfoResponse(
280 const RilRadioResponseInfo &responseInfo, const CallForwardQueryInfoList &cFQueryList) override;
281 int32_t SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo) override;
282 int32_t GetCallRestrictionResponse(
283 const RilRadioResponseInfo &responseInfo, const CallRestrictionResult &result) override;
284 int32_t SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo) override;
285 int32_t GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult) override;
286 int32_t SetClirResponse(const RilRadioResponseInfo &responseInfo) override;
287 int32_t StartDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
288 int32_t SendDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
289 int32_t StopDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
290 int32_t GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
291 int32_t SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo) override;
292 int32_t SetUssdResponse(const RilRadioResponseInfo &responseInfo) override;
293 int32_t GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd) override;
294 int32_t SetMuteResponse(const RilRadioResponseInfo &responseInfo) override;
295 int32_t GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute) override;
296 int32_t GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail) override;
297 int32_t SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo) override;
298 int32_t CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo) override;
299 int32_t SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo) override;
300
301 // Data
302 int32_t PdpContextListUpdated(
303 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList) override;
304 int32_t DataLinkCapabilityUpdated(
305 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability) override;
306 int32_t ActivatePdpContextResponse(
307 const RilRadioResponseInfo &responseInfo, const SetupDataCallResultInfo &setupDataCallResultInfo) override;
308 int32_t DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo) override;
309 int32_t GetPdpContextListResponse(
310 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList) override;
311 int32_t SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo) override;
312 int32_t SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo) override;
313 int32_t GetLinkBandwidthInfoResponse(
314 const RilRadioResponseInfo &responseInfo, const DataLinkBandwidthInfo &dataLinkBandwidthInfo) override;
315 int32_t SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo) override;
316 int32_t SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo);
317 int32_t GetLinkCapabilityResponse(
318 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability) override;
319 int32_t CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo) override;
320 int32_t NcfgFinishedResult(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
321 int32_t RestartRildNvMatch(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
322 int32_t NetworkSliceUrspRpt(const RilRadioResponseInfo &responseInfo,
323 const NetworkSliceUrspInfo &networkSliceUrspInfo) override;
324 int32_t NetworkSliceAllowedNssaiRpt(const RilRadioResponseInfo &responseInfo,
325 const NetworkSliceAllowedNssaiInfo &networkSliceAllowedNssaiInfo) override;
326 int32_t NetworkSliceEhplmnRpt(const RilRadioResponseInfo &responseInfo,
327 const NetworkSliceEhplmnInfo &networkSliceEhplmnInfo) override;
328 // Modem
329 int32_t RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state) override;
330 int32_t VoiceRadioTechUpdated(
331 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology) override;
332 int32_t DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
333 int32_t ShutDownResponse(const RilRadioResponseInfo &responseInfo) override;
334 int32_t SetRadioStateResponse(const RilRadioResponseInfo &responseInfo) override;
335 int32_t GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state) override;
336 int32_t GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei) override;
337 int32_t GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv) override;
338 int32_t GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid) override;
339 int32_t GetVoiceRadioTechnologyResponse(
340 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology) override;
341 int32_t GetBasebandVersionResponse(
342 const RilRadioResponseInfo &responseInfo, const std::string &basebandVersion) override;
343
344 // Sim notice
345 int32_t SimStateUpdated(const RilRadioResponseInfo &responseInfo) override;
346 int32_t SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo) override;
347 int32_t SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
348 int32_t SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
349 int32_t SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
350 int32_t SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo) override;
351 int32_t SimRefreshNotify(const RilRadioResponseInfo &responseInfo) override;
SimRadioProtocolUpdated(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)352 int32_t SimRadioProtocolUpdated(
353 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override
354 {
355 return 0;
356 }
357 // Sim response
358 int32_t GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
359 int32_t GetSimStatusResponse(const RilRadioResponseInfo &responseInfo, const CardStatusInfo &result) override;
360 int32_t GetSimCardStatusResponse(const RilRadioResponseInfo &responseInfo,
361 const SimCardStatusInfo &result) override;
362 int32_t GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
363 int32_t GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus) override;
364 int32_t SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
365 int32_t ChangeSimPasswordResponse(
366 const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
367 int32_t UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
368 int32_t UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
369 int32_t UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
370 int32_t UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
371 int32_t SetActiveSimResponse(const RilRadioResponseInfo &responseInfo) override;
372 int32_t SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo) override;
373 int32_t SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo) override;
374 int32_t SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo) override;
375 int32_t SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo) override;
376 int32_t SetRadioProtocolResponse(
377 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override;
GetRadioProtocolResponse(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)378 int32_t GetRadioProtocolResponse(
379 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override
380 {
381 return 0;
382 }
383 int32_t SimOpenLogicalChannelResponse(const RilRadioResponseInfo &responseInfo,
384 const OpenLogicalChannelResponse &pOpenLogicalChannelResponse) override;
385 int32_t SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo) override;
386 int32_t SimTransmitApduLogicalChannelResponse(
387 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
388 int32_t SimTransmitApduBasicChannelResponse(
389 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
390 int32_t SimAuthenticationResponse(
391 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
392 int32_t UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
393 int32_t SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo) override;
394 int32_t GetPrimarySlotResponse(const RilRadioResponseInfo &responseInfo, int32_t slotId) override;
395 int32_t SetPrimarySlotResponse(const RilRadioResponseInfo &responseInfo) override;
396
397 // Network
398 int32_t NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
399 const CsRegStatusInfo &csRegStatusInfo) override;
400 int32_t NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
401 const PsRegStatusInfo &psRegStatusInfo) override;
402 int32_t SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi) override;
403 int32_t NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr) override;
404 int32_t NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr) override;
405 int32_t NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo,
406 const ChannelConfigInfoList &channelConfigInfoList) override;
407 int32_t NetworkCurrentCellUpdated(
408 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellListCurrentInfo) override;
409 int32_t NetworkCurrentCellUpdated_1_1(
410 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo) override;
411 int32_t NetworkCurrentCellUpdated_1_2(
412 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo) override;
413 int32_t ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn) override;
414 int32_t GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi) override;
415 int32_t GetCsRegStatusResponse(
416 const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo) override;
417 int32_t GetPsRegStatusResponse(
418 const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo) override;
419 int32_t GetOperatorInfoResponse(
420 const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo) override;
421 int32_t GetNetworkSearchInformationResponse(
422 const RilRadioResponseInfo &responseInfo, const AvailableNetworkList &availableNetworkList) override;
423 int32_t GetNetworkSelectionModeResponse(
424 const RilRadioResponseInfo &responseInfo, const SetNetworkModeInfo &setNetworkModeInfo) override;
425 int32_t SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo) override;
426 int32_t GetNeighboringCellInfoListResponse(
427 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo &cellInfoList) override;
428 int32_t GetNeighboringCellInfoListResponse_1_2(
429 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo_1_2 &cellInfoList) override;
430 int32_t GetCurrentCellInfoResponse(
431 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellInfoList) override;
432 int32_t GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo &responseInfo,
433 const CellListCurrentInfo_1_1 &cellListCurrentInfo) override;
434 int32_t GetCurrentCellInfoResponse_1_2(
435 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo) override;
436 int32_t SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo) override;
437 int32_t GetPreferredNetworkResponse(
438 const RilRadioResponseInfo &responseInfo, const PreferredNetworkTypeInfo &preferredNetworkTypeInfo) override;
439 int32_t GetPhysicalChannelConfigResponse(
440 const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList) override;
441 int32_t SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo) override;
442 int32_t SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo) override;
443 int32_t SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo) override;
444 int32_t GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state) override;
445 int32_t SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo) override;
446 int32_t GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
447 int32_t GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state) override;
448 int32_t GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds) override;
449
450 // Sms
451 int32_t NewSmsNotify(
452 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
453 int32_t NewCdmaSmsNotify(
454 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
455 int32_t SmsStatusReportNotify(
456 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
457 int32_t NewSmsStoredOnSimNotify(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t recordNumber,
458 int32_t indicationType) override;
459 int32_t CBConfigNotify(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
460 const CBConfigReportInfo &cellBroadConfigReportInfo) override;
461 int32_t SendGsmSmsResponse(
462 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
463 int32_t SendCdmaSmsResponse(
464 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
465 int32_t AddSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
466 int32_t DelSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
467 int32_t UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
468 int32_t AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
469 int32_t DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
470 int32_t UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
471 int32_t SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo) override;
472 int32_t GetSmscAddrResponse(
473 const RilRadioResponseInfo &responseInfo, const ServiceCenterAddress &serviceCenterAddress) override;
474 int32_t SetCBConfigResponse(const RilRadioResponseInfo &responseInfo) override;
475 int32_t GetCBConfigResponse(
476 const RilRadioResponseInfo &responseInfo, const CBConfigInfo &cellBroadcastInfo) override;
477 int32_t SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo) override;
478 int32_t GetCdmaCBConfigResponse(
479 const RilRadioResponseInfo &responseInfo, const CdmaCBConfigInfo &cdmaCBConfigInfo) override;
480 int32_t SendSmsMoreModeResponse(
481 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
482 int32_t SendSmsAckResponse(const RilRadioResponseInfo &responseInfo) override;
483
484 int32_t CommonErrorResponse(const RilRadioResponseInfo &responseInfo) override;
485
486 int32_t GetCallListResponseExt(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo& responseInfo,
487 const OHOS::HDI::Ril::V1_4::CallInfoExtList& callList) override;
488 private:
489 std::mutex callbackMutex_;
490 std::condition_variable cv_;
491 HdiId hdiId_;
492 RilRadioResponseInfo resultInfo_;
493 };
494
495 class HdfRilHdiTest : public testing::Test {
496 public:
497 static void SetUpTestCase();
498 static void TearDownTestCase();
499 void SetUp();
500 void TearDown();
501 };
502
503 namespace {
504 sptr<OHOS::HDI::Ril::V1_5::IRil> g_rilInterface = nullptr;
505 RilCallback callback_;
506 constexpr static int32_t SLOTID_1 = 0;
507 constexpr static int32_t SLOTID_2 = 1;
508 constexpr static int32_t SUCCESS = 0;
509 constexpr static int32_t WAIT_TIME_SECOND = 20;
510 constexpr static int32_t WAIT_TIME_SECOND_LONG = 40;
511 constexpr static int32_t CID = 1;
512 constexpr static int32_t REASON = 2;
513 std::map<int32_t, int32_t> simState_;
514 int32_t currentChannelId_ = 1;
515 constexpr int32_t TEST_TOSCA = 0;
516 const std::string TEST_STORAGE_PDU = "1234";
517 const std::string TEST_SEND_PDU = "A10305810180F6000004F4F29C0E";
518 const std::string TEST_SMSC_PDU = "00";
519 const std::string TEST_CDMA_PDU = "pdu";
520 const std::string TEST_SMSC_ADDR = "00";
521 const std::string TEST_ID_LIST = "0,1,5,320-478,922";
522 const std::string TEST_DCS_LIST = "0-3,5";
523 const int32_t TEST_MODE = 0;
524 const bool TEST_RESULT = true;
525 int32_t currentSerialId = 0;
526 } // namespace
527
528 /**
529 ** common fun
530 **/
WaitFor(int32_t timeoutSecond)531 void WaitFor(int32_t timeoutSecond)
532 {
533 callback_.WaitFor(WAIT_TIME_SECOND);
534 }
535
GetBoolResult(HdiId hdiId_)536 bool GetBoolResult(HdiId hdiId_)
537 {
538 return callback_.GetBoolResult(hdiId_);
539 }
540
GetSerialId()541 int32_t GetSerialId()
542 {
543 currentSerialId = rand() % 10000000000;
544 return currentSerialId;
545 }
546
IsReady(int32_t slotId)547 bool IsReady(int32_t slotId)
548 {
549 if (g_rilInterface == nullptr) {
550 return false;
551 }
552 return simState_[slotId] != 0 && simState_[slotId] != -1;
553 }
554
555 /**
556 ** RilCallback implement
557 **/
558
NotifyAll()559 void RilCallback::NotifyAll()
560 {
561 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
562 if (resultInfo_.serial != currentSerialId) {
563 hdiId_ = HdiId::HREQ_NONE;
564 HDF_LOGI("NotifyAll currentSerialId : %{public}d, serial: %{public}d not equal", currentSerialId,
565 resultInfo_.serial);
566 return;
567 }
568 cv_.notify_all();
569 }
570
WaitFor(int32_t timeoutSecond)571 void RilCallback::WaitFor(int32_t timeoutSecond)
572 {
573 Clean();
574 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
575 cv_.wait_for(callbackLock, std::chrono::seconds(timeoutSecond));
576 }
577
Clean()578 void RilCallback::Clean()
579 {
580 hdiId_ = HdiId::HREQ_NONE;
581 }
582
GetBoolResult(HdiId hdiId)583 bool RilCallback::GetBoolResult(HdiId hdiId)
584 {
585 HDF_LOGI("GetBoolResult hdiId: %{public}d, error: %{public}d", hdiId, (int32_t)resultInfo_.error);
586 bool ret = false;
587 if (hdiId_ == HdiId::HREQ_NONE) {
588 HDF_LOGE("response timeout, not implemented."
589 "hdiId: %d, current hdiId_: %{public}d",
590 (int32_t)hdiId, hdiId_);
591 ret = true;
592 Clean();
593 return ret;
594 }
595 if (hdiId_ != hdiId) {
596 ret = false;
597 HDF_LOGE(
598 "GetBoolResult hdiId does not match. hdiId: %{public}d, current hdiId: %{public}d", (int32_t)hdiId, hdiId_);
599 Clean();
600 return ret;
601 }
602 ret = true;
603 Clean();
604 return ret;
605 }
606
607 // SIM
SimStateUpdated(const RilRadioResponseInfo & responseInfo)608 int32_t RilCallback::SimStateUpdated(const RilRadioResponseInfo &responseInfo)
609 {
610 HDF_LOGI("SimStateUpdated notice : slotId = %{public}d", responseInfo.slotId);
611 g_rilInterface->GetSimStatus(responseInfo.slotId, GetSerialId());
612 return 0;
613 }
614
SimStkSessionEndNotify(const RilRadioResponseInfo & responseInfo)615 int32_t RilCallback::SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo)
616 {
617 HDF_LOGI("SimStkSessionEndNotify notice : slotId = %{public}d", responseInfo.slotId);
618 return 0;
619 }
620
SimStkProactiveNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)621 int32_t RilCallback::SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
622 {
623 HDF_LOGI("SimStkProactiveNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId,
624 response.c_str());
625 return 0;
626 }
627
SimStkAlphaNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)628 int32_t RilCallback::SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
629 {
630 HDF_LOGI(
631 "SimStkAlphaNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId, response.c_str());
632 return 0;
633 }
634
SimStkEventNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)635 int32_t RilCallback::SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
636 {
637 HDF_LOGI(
638 "SimStkEventNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId, response.c_str());
639 return 0;
640 }
641
SimStkCallSetupNotify(const RilRadioResponseInfo & responseInfo)642 int32_t RilCallback::SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo)
643 {
644 HDF_LOGI("SimStkCallSetupNotify notice : slotId = %{public}d", responseInfo.slotId);
645 return 0;
646 }
647
SimRefreshNotify(const RilRadioResponseInfo & responseInfo)648 int32_t RilCallback::SimRefreshNotify(const RilRadioResponseInfo &responseInfo)
649 {
650 HDF_LOGI("SimRefreshNotify notice : slotId = %{public}d", responseInfo.slotId);
651 return 0;
652 }
653
GetSimStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const HDI::Ril::V1_1::CardStatusInfo & result)654 int32_t RilCallback::GetSimStatusResponse(
655 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const HDI::Ril::V1_1::CardStatusInfo &result)
656 {
657 HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, simState = %{public}d",
658 responseInfo.slotId, result.simType, result.simState);
659 simState_[responseInfo.slotId] = result.simState;
660 HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, simState_[responseInfo.slotId]);
661 hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
662 resultInfo_ = responseInfo;
663 NotifyAll();
664 return 0;
665 }
666
GetSimCardStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const HDI::Ril::V1_4::SimCardStatusInfo & result)667 int32_t RilCallback::GetSimCardStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
668 const HDI::Ril::V1_4::SimCardStatusInfo &result)
669 {
670 HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, simState = %{public}d",
671 responseInfo.slotId, result.simType, result.simState);
672 simState_[responseInfo.slotId] = result.simState;
673 HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, simState_[responseInfo.slotId]);
674 hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
675 resultInfo_ = responseInfo;
676 NotifyAll();
677 return 0;
678 }
679
GetSimIOResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)680 int32_t RilCallback::GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
681 {
682 HDF_LOGI("GetBoolResult GetSimIO result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s", result.sw1,
683 result.sw2, result.response.c_str());
684 hdiId_ = HdiId::HREQ_SIM_GET_SIM_IO;
685 resultInfo_ = responseInfo;
686 NotifyAll();
687 return 0;
688 }
689
GetImsiResponse(const RilRadioResponseInfo & responseInfo,const std::string & response)690 int32_t RilCallback::GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response)
691 {
692 HDF_LOGI("GetBoolResult GetImsi result : response = %{public}s", response.c_str());
693 hdiId_ = HdiId::HREQ_SIM_GET_IMSI;
694 resultInfo_ = responseInfo;
695 NotifyAll();
696 return 0;
697 }
GetSimLockStatusResponse(const RilRadioResponseInfo & responseInfo,int32_t simLockStatus)698 int32_t RilCallback::GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus)
699 {
700 HDF_LOGI("GetBoolResult GetSimLockStatus result : simLockStatus = %{public}d", simLockStatus);
701 hdiId_ = HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS;
702 resultInfo_ = responseInfo;
703 NotifyAll();
704 return 0;
705 }
SetSimLockResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)706 int32_t RilCallback::SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
707 {
708 HDF_LOGI("GetBoolResult SetSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
709 lockStatus.remain);
710 hdiId_ = HdiId::HREQ_SIM_SET_SIM_LOCK;
711 resultInfo_ = responseInfo;
712 NotifyAll();
713 return 0;
714 }
ChangeSimPasswordResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)715 int32_t RilCallback::ChangeSimPasswordResponse(
716 const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
717 {
718 HDF_LOGI("GetBoolResult ChangeSimPassword result : result = %{public}d, remain = %{public}d", lockStatus.result,
719 lockStatus.remain);
720 hdiId_ = HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD;
721 resultInfo_ = responseInfo;
722 NotifyAll();
723 return 0;
724 }
UnlockPinResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)725 int32_t RilCallback::UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
726 {
727 HDF_LOGI("GetBoolResult UnlockPin result : result = %{public}d, remain = %{public}d", lockStatus.result,
728 lockStatus.remain);
729 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN;
730 resultInfo_ = responseInfo;
731 NotifyAll();
732 return 0;
733 }
UnlockPukResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)734 int32_t RilCallback::UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
735 {
736 HDF_LOGI("GetBoolResult UnlockPuk result : result = %{public}d, remain = %{public}d", lockStatus.result,
737 lockStatus.remain);
738 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK;
739 resultInfo_ = responseInfo;
740 NotifyAll();
741 return 0;
742 }
UnlockPin2Response(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)743 int32_t RilCallback::UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
744 {
745 HDF_LOGI("GetBoolResult UnlockPin2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
746 lockStatus.remain);
747 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN2;
748 resultInfo_ = responseInfo;
749 NotifyAll();
750 return 0;
751 }
UnlockPuk2Response(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)752 int32_t RilCallback::UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
753 {
754 HDF_LOGI("GetBoolResult UnlockPuk2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
755 lockStatus.remain);
756 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK2;
757 resultInfo_ = responseInfo;
758 NotifyAll();
759 return 0;
760 }
761
SetActiveSimResponse(const RilRadioResponseInfo & responseInfo)762 int32_t RilCallback::SetActiveSimResponse(const RilRadioResponseInfo &responseInfo)
763 {
764 HDF_LOGI("GetBoolResult SetActiveSim result");
765 hdiId_ = HdiId::HREQ_SIM_SET_ACTIVE_SIM;
766 resultInfo_ = responseInfo;
767 NotifyAll();
768 return 0;
769 }
770
SimStkSendTerminalResponseResponse(const RilRadioResponseInfo & responseInfo)771 int32_t RilCallback::SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo)
772 {
773 HDF_LOGI("GetBoolResult SimStkSendTerminalResponse result");
774 hdiId_ = HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE;
775 resultInfo_ = responseInfo;
776 NotifyAll();
777 return 0;
778 }
779
SimStkSendEnvelopeResponse(const RilRadioResponseInfo & responseInfo)780 int32_t RilCallback::SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo)
781 {
782 HDF_LOGI("GetBoolResult SimStkSendEnvelope result");
783 hdiId_ = HdiId::HREQ_SIM_STK_SEND_ENVELOPE;
784 resultInfo_ = responseInfo;
785 NotifyAll();
786 return 0;
787 }
788
SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo & responseInfo)789 int32_t RilCallback::SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo)
790 {
791 HDF_LOGI("GetBoolResult SimStkSendCallSetupRequestResult result");
792 hdiId_ = HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT;
793 resultInfo_ = responseInfo;
794 NotifyAll();
795 return 0;
796 }
797
SimStkIsReadyResponse(const RilRadioResponseInfo & responseInfo)798 int32_t RilCallback::SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo)
799 {
800 HDF_LOGI("GetBoolResult SimStkIsReady result");
801 hdiId_ = HdiId::HREQ_SIM_STK_IS_READY;
802 resultInfo_ = responseInfo;
803 NotifyAll();
804 return 0;
805 }
806
SetRadioProtocolResponse(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)807 int32_t RilCallback::SetRadioProtocolResponse(
808 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol)
809 {
810 HDF_LOGI("GetBoolResult SetRadioProtocol result : phase = %{public}d, slotId = %{public}d", radioProtocol.phase,
811 radioProtocol.slotId);
812 hdiId_ = HdiId::HREQ_SIM_RADIO_PROTOCOL;
813 resultInfo_ = responseInfo;
814 NotifyAll();
815 return 0;
816 }
817
SimOpenLogicalChannelResponse(const RilRadioResponseInfo & responseInfo,const OpenLogicalChannelResponse & pOpenLogicalChannelResponse)818 int32_t RilCallback::SimOpenLogicalChannelResponse(
819 const RilRadioResponseInfo &responseInfo, const OpenLogicalChannelResponse &pOpenLogicalChannelResponse)
820 {
821 HDF_LOGI("GetBoolResult SimOpenLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, channelId = %{public}d, "
822 "response = %{public}s",
823 pOpenLogicalChannelResponse.sw1, pOpenLogicalChannelResponse.sw2, pOpenLogicalChannelResponse.channelId,
824 pOpenLogicalChannelResponse.response.c_str());
825 currentChannelId_ = pOpenLogicalChannelResponse.channelId;
826 hdiId_ = HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL;
827 resultInfo_ = responseInfo;
828 NotifyAll();
829 return 0;
830 }
831
SimCloseLogicalChannelResponse(const RilRadioResponseInfo & responseInfo)832 int32_t RilCallback::SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo)
833 {
834 HDF_LOGI("GetBoolResult SimCloseLogicalChannel result");
835 hdiId_ = HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL;
836 resultInfo_ = responseInfo;
837 NotifyAll();
838 return 0;
839 }
840
SimTransmitApduLogicalChannelResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)841 int32_t RilCallback::SimTransmitApduLogicalChannelResponse(
842 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
843 {
844 HDF_LOGI("GetBoolResult SimTransmitApduLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, response = "
845 "%{public}s",
846 result.sw1, result.sw2, result.response.c_str());
847 hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL;
848 resultInfo_ = responseInfo;
849 NotifyAll();
850 return 0;
851 }
852
SimTransmitApduBasicChannelResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)853 int32_t RilCallback::SimTransmitApduBasicChannelResponse(
854 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
855 {
856 HDF_LOGI(
857 "GetBoolResult SimTransmitApduBasicChannel result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
858 result.sw1, result.sw2, result.response.c_str());
859 hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL;
860 resultInfo_ = responseInfo;
861 NotifyAll();
862 return 0;
863 }
SimAuthenticationResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)864 int32_t RilCallback::SimAuthenticationResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
865 {
866 HDF_LOGI("GetBoolResult SimAuthentication result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
867 result.sw1, result.sw2, result.response.c_str());
868 hdiId_ = HdiId::HREQ_SIM_AUTHENTICATION;
869 resultInfo_ = responseInfo;
870 NotifyAll();
871 return 0;
872 }
873
UnlockSimLockResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)874 int32_t RilCallback::UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
875 {
876 HDF_LOGI("GetBoolResult UnlockSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
877 lockStatus.remain);
878 hdiId_ = HdiId::HREQ_SIM_UNLOCK_SIM_LOCK;
879 resultInfo_ = responseInfo;
880 NotifyAll();
881 return 0;
882 }
883
SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo & responseInfo)884 int32_t RilCallback::SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo)
885 {
886 HDF_LOGI("GetBoolResult SendSimMatchedOperatorInfo result");
887 hdiId_ = HdiId::HREQ_SIM_SEND_NCFG_OPER_INFO;
888 resultInfo_ = responseInfo;
889 NotifyAll();
890 return 0;
891 }
GetPrimarySlotResponse(const RilRadioResponseInfo & responseInfo,int32_t slotId)892 int32_t RilCallback::GetPrimarySlotResponse(const RilRadioResponseInfo &responseInfo, int32_t slotId)
893 {
894 HDF_LOGI("GetBoolResult GetPrimarySlot result, slotId = %{public}d", slotId);
895 hdiId_ = HdiId::HREQ_SIM_GET_PRIMARY_SLOT;
896 resultInfo_ = responseInfo;
897 NotifyAll();
898 return 0;
899 }
900
SetPrimarySlotResponse(const RilRadioResponseInfo & responseInfo)901 int32_t RilCallback::SetPrimarySlotResponse(const RilRadioResponseInfo &responseInfo)
902 {
903 HDF_LOGI("GetBoolResult SetPrimarySlot result");
904 hdiId_ = HdiId::HREQ_SIM_SET_PRIMARY_SLOT;
905 resultInfo_ = responseInfo;
906 NotifyAll();
907 return 0;
908 }
909
910
911 // Network
NetworkCsRegStatusUpdated(const RilRadioResponseInfo & responseInfo,const CsRegStatusInfo & csRegStatusInfo)912 int32_t RilCallback::NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
913 const CsRegStatusInfo &csRegStatusInfo)
914 {
915 HDF_LOGI("RilCallback::NetworkCsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, "
916 "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
917 csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
918 csRegStatusInfo.radioTechnology);
919 return 0;
920 }
921
NetworkPsRegStatusUpdated(const RilRadioResponseInfo & responseInfo,const PsRegStatusInfo & psRegStatusInfo)922 int32_t RilCallback::NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
923 const PsRegStatusInfo &psRegStatusInfo)
924 {
925 HDF_LOGI(
926 "RilCallback::NetworkPsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
927 "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
928 psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
929 psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
930 psRegStatusInfo.isEnDcAvailable);
931 return 0;
932 }
933
SignalStrengthUpdated(const RilRadioResponseInfo & responseInfo,const Rssi & rssi)934 int32_t RilCallback::SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
935 {
936 HDF_LOGI("RilCallback::SignalStrengthUpdated rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
937 return 0;
938 }
939
NetworkTimeZoneUpdated(const RilRadioResponseInfo & responseInfo,const std::string & timeZoneStr)940 int32_t RilCallback::NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr)
941 {
942 HDF_LOGI("RilCallback::NetworkTimeZoneUpdated timeZone:%{public}s", timeZoneStr.c_str());
943 return 0;
944 }
945
NetworkTimeUpdated(const RilRadioResponseInfo & responseInfo,const std::string & timeStr)946 int32_t RilCallback::NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr)
947 {
948 HDF_LOGI("RilCallback::NetworkTimeZoneUpdated time:%{public}s", timeStr.c_str());
949 return 0;
950 }
951
NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo & responseInfo,const ChannelConfigInfoList & channelConfigInfoList)952 int32_t RilCallback::NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo,
953 const ChannelConfigInfoList &channelConfigInfoList)
954 {
955 HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated itemNum:%{public}d", channelConfigInfoList.itemNum);
956 for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
957 HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated cellConnStatus:%{public}d, "
958 "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
959 "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
960 "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
961 phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
962 phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
963 phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
964 for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
965 HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
966 }
967 }
968 return 0;
969 }
970
NetworkCurrentCellUpdated(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo & cellListCurrentInfo)971 int32_t RilCallback::NetworkCurrentCellUpdated(
972 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellListCurrentInfo)
973 {
974 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated itemNum:%{public}d", cellListCurrentInfo.itemNum);
975 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
976 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
977 info.ratType, info.mcc, info.mnc);
978 switch (static_cast<RatType>(info.ratType)) {
979 case RatType::NETWORK_TYPE_LTE:
980 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
981 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
982 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
983 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
984 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
985 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
986 break;
987 case RatType::NETWORK_TYPE_GSM:
988 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
989 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
990 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
991 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
992 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
993 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
994 break;
995 case RatType::NETWORK_TYPE_WCDMA:
996 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
997 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
998 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
999 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1000 break;
1001 case RatType::NETWORK_TYPE_NR:
1002 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1003 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1004 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1005 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1006 break;
1007 default:
1008 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated invalid ratType");
1009 }
1010 }
1011 return 0;
1012 }
1013
NetworkCurrentCellUpdated_1_1(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_1 & cellListCurrentInfo)1014 int32_t RilCallback::NetworkCurrentCellUpdated_1_1(
1015 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)
1016 {
1017 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
1018 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1019 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
1020 info.ratType, info.mcc, info.mnc);
1021 switch (static_cast<RatType>(info.ratType)) {
1022 case RatType::NETWORK_TYPE_LTE:
1023 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1024 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1025 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1026 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1027 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1028 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1029 break;
1030 case RatType::NETWORK_TYPE_GSM:
1031 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1032 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1033 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1034 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1035 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1036 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1037 break;
1038 case RatType::NETWORK_TYPE_WCDMA:
1039 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1040 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1041 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1042 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1043 break;
1044 case RatType::NETWORK_TYPE_NR:
1045 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1046 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1047 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1048 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1049 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1050 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1051 break;
1052 default:
1053 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated_1_1 invalid ratType");
1054 }
1055 }
1056 return 0;
1057 }
1058
NetworkCurrentCellUpdated_1_2(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_2 & cellListCurrentInfo)1059 int32_t RilCallback::NetworkCurrentCellUpdated_1_2(
1060 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)
1061 {
1062 HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
1063 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1064 HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
1065 switch (static_cast<RatType>(info.ratType)) {
1066 case RatType::NETWORK_TYPE_LTE:
1067 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1068 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1069 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1070 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1071 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1072 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1073 break;
1074 case RatType::NETWORK_TYPE_GSM:
1075 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1076 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1077 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1078 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1079 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1080 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1081 break;
1082 case RatType::NETWORK_TYPE_WCDMA:
1083 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1084 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1085 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1086 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1087 break;
1088 case RatType::NETWORK_TYPE_NR:
1089 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1090 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1091 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1092 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1093 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1094 break;
1095 default:
1096 HDF_LOGE("invalid ratType");
1097 break;
1098 }
1099 }
1100 return 0;
1101 }
1102
ResidentNetworkUpdated(const RilRadioResponseInfo & responseInfo,const std::string & plmn)1103 int32_t RilCallback::ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn)
1104 {
1105 HDF_LOGI("RilCallback::ResidentNetworkUpdated plmn:%{public}s", plmn.c_str());
1106 return 0;
1107 }
1108
GetSignalStrengthResponse(const RilRadioResponseInfo & responseInfo,const Rssi & rssi)1109 int32_t RilCallback::GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
1110 {
1111 HDF_LOGI("RilCallback::GetSignalStrengthResponse rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
1112 hdiId_ = HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH;
1113 resultInfo_ = responseInfo;
1114 NotifyAll();
1115 return 0;
1116 }
1117
GetCsRegStatusResponse(const RilRadioResponseInfo & responseInfo,const CsRegStatusInfo & csRegStatusInfo)1118 int32_t RilCallback::GetCsRegStatusResponse(
1119 const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo)
1120 {
1121 HDF_LOGI("RilCallback::GetCsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, "
1122 "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
1123 csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
1124 csRegStatusInfo.radioTechnology);
1125 hdiId_ = HdiId::HREQ_NETWORK_GET_CS_REG_STATUS;
1126 resultInfo_ = responseInfo;
1127 NotifyAll();
1128 return 0;
1129 }
1130
GetPsRegStatusResponse(const RilRadioResponseInfo & responseInfo,const PsRegStatusInfo & psRegStatusInfo)1131 int32_t RilCallback::GetPsRegStatusResponse(
1132 const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo)
1133 {
1134 HDF_LOGI(
1135 "RilCallback::GetPsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
1136 "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
1137 psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
1138 psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
1139 psRegStatusInfo.isEnDcAvailable);
1140 hdiId_ = HdiId::HREQ_NETWORK_GET_PS_REG_STATUS;
1141 resultInfo_ = responseInfo;
1142 NotifyAll();
1143 return 0;
1144 }
1145
GetOperatorInfoResponse(const RilRadioResponseInfo & responseInfo,const OperatorInfo & operatorInfo)1146 int32_t RilCallback::GetOperatorInfoResponse(
1147 const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo)
1148 {
1149 HDF_LOGI("RilCallback::GetOperatorInfoResponse longName:%{public}s, shortName:%{public}s, numeric:%{public}s",
1150 operatorInfo.longName.c_str(), operatorInfo.shortName.c_str(), operatorInfo.numeric.c_str());
1151 hdiId_ = HdiId::HREQ_NETWORK_GET_OPERATOR_INFO;
1152 resultInfo_ = responseInfo;
1153 NotifyAll();
1154 return 0;
1155 }
1156
GetNetworkSearchInformationResponse(const RilRadioResponseInfo & responseInfo,const AvailableNetworkList & availableNetworkList)1157 int32_t RilCallback::GetNetworkSearchInformationResponse(
1158 const RilRadioResponseInfo &responseInfo, const AvailableNetworkList &availableNetworkList)
1159 {
1160 HDF_LOGI("RilCallback::GetNetworkSearchInformationResponse itemNum:%{public}d", availableNetworkList.itemNum);
1161 for (auto availableInfo : availableNetworkList.availableNetworkInfo) {
1162 HDF_LOGI("status:%{public}d", availableInfo.status);
1163 HDF_LOGI("numeric:%{public}s", availableInfo.numeric.c_str());
1164 HDF_LOGI("shortName:%{public}s", availableInfo.shortName.c_str());
1165 HDF_LOGI("longName:%{public}s", availableInfo.longName.c_str());
1166 HDF_LOGI("rat:%{public}d", availableInfo.rat);
1167 }
1168 hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION;
1169 resultInfo_ = responseInfo;
1170 NotifyAll();
1171 return 0;
1172 }
1173
GetNetworkSelectionModeResponse(const RilRadioResponseInfo & responseInfo,const SetNetworkModeInfo & setNetworkModeInfo)1174 int32_t RilCallback::GetNetworkSelectionModeResponse(
1175 const RilRadioResponseInfo &responseInfo, const SetNetworkModeInfo &setNetworkModeInfo)
1176 {
1177 HDF_LOGI("RilCallback::GetNetworkSelectionModeResponse selectMode:%{public}d", setNetworkModeInfo.selectMode);
1178 hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE;
1179 resultInfo_ = responseInfo;
1180 NotifyAll();
1181 return 0;
1182 }
1183
SetNetworkSelectionModeResponse(const RilRadioResponseInfo & responseInfo)1184 int32_t RilCallback::SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo)
1185 {
1186 HDF_LOGI("RilCallback::SetNetworkSelectionModeResponse error:%{public}d", responseInfo.error);
1187 hdiId_ = HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE;
1188 resultInfo_ = responseInfo;
1189 NotifyAll();
1190 return 0;
1191 }
1192
GetNeighboringCellInfoListResponse(const RilRadioResponseInfo & responseInfo,const CellListNearbyInfo & cellInfoList)1193 int32_t RilCallback::GetNeighboringCellInfoListResponse(
1194 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo &cellInfoList)
1195 {
1196 HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse itemNum:%{public}d", cellInfoList.itemNum);
1197 for (auto info : cellInfoList.cellNearbyInfo) {
1198 HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse ratType:%{public}d", info.ratType);
1199 switch (static_cast<RatType>(info.ratType)) {
1200 case RatType::NETWORK_TYPE_LTE:
1201 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1202 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1203 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1204 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1205 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
1206 break;
1207 case RatType::NETWORK_TYPE_GSM:
1208 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1209 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1210 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1211 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1212 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1213 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1214 break;
1215 case RatType::NETWORK_TYPE_WCDMA:
1216 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1217 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1218 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1219 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1220 break;
1221 case RatType::NETWORK_TYPE_NR:
1222 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1223 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1224 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1225 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1226 break;
1227 default:
1228 HDF_LOGE("RilCallback::GetNeighboringCellInfoListResponse invalid ratType");
1229 }
1230 }
1231 hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
1232 resultInfo_ = responseInfo;
1233 NotifyAll();
1234 return 0;
1235 }
1236
GetNeighboringCellInfoListResponse_1_2(const RilRadioResponseInfo & responseInfo,const CellListNearbyInfo_1_2 & cellInfoList)1237 int32_t RilCallback::GetNeighboringCellInfoListResponse_1_2(
1238 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo_1_2 &cellInfoList)
1239 {
1240 HDF_LOGI("itemNum:%{public}d", cellInfoList.itemNum);
1241 for (auto info : cellInfoList.cellNearbyInfo) {
1242 HDF_LOGI("ratType:%{public}d", info.ratType);
1243 switch (static_cast<RatType>(info.ratType)) {
1244 case RatType::NETWORK_TYPE_LTE:
1245 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1246 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1247 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1248 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1249 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
1250 break;
1251 case RatType::NETWORK_TYPE_GSM:
1252 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1253 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1254 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1255 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1256 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1257 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1258 break;
1259 case RatType::NETWORK_TYPE_WCDMA:
1260 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1261 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1262 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1263 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1264 break;
1265 case RatType::NETWORK_TYPE_NR:
1266 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1267 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1268 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1269 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1270 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1271 break;
1272 default:
1273 HDF_LOGE("invalid ratType");
1274 break;
1275 }
1276 }
1277 hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
1278 resultInfo_ = responseInfo;
1279 NotifyAll();
1280 return 0;
1281 }
1282
GetCurrentCellInfoResponse(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo & cellInfoList)1283 int32_t RilCallback::GetCurrentCellInfoResponse(
1284 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellInfoList)
1285 {
1286 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse itemNum:%{public}d", cellInfoList.itemNum);
1287 for (auto info : cellInfoList.cellCurrentInfo) {
1288 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
1289 info.ratType, info.mcc, info.mnc);
1290 switch (static_cast<RatType>(info.ratType)) {
1291 case RatType::NETWORK_TYPE_LTE:
1292 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1293 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1294 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1295 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1296 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1297 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1298 break;
1299 case RatType::NETWORK_TYPE_GSM:
1300 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1301 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1302 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1303 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1304 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1305 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1306 break;
1307 case RatType::NETWORK_TYPE_WCDMA:
1308 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1309 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1310 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1311 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1312 break;
1313 case RatType::NETWORK_TYPE_NR:
1314 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1315 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1316 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1317 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1318 break;
1319 default:
1320 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse invalid ratType");
1321 }
1322 }
1323 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1324 resultInfo_ = responseInfo;
1325 NotifyAll();
1326 return 0;
1327 }
1328
GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_1 & cellListCurrentInfo)1329 int32_t RilCallback::GetCurrentCellInfoResponse_1_1(
1330 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)
1331 {
1332 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
1333 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1334 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
1335 info.ratType, info.mcc, info.mnc);
1336 switch (static_cast<RatType>(info.ratType)) {
1337 case RatType::NETWORK_TYPE_LTE:
1338 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1339 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1340 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1341 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1342 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1343 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1344 break;
1345 case RatType::NETWORK_TYPE_GSM:
1346 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1347 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1348 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1349 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1350 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1351 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1352 break;
1353 case RatType::NETWORK_TYPE_WCDMA:
1354 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1355 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1356 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1357 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1358 break;
1359 case RatType::NETWORK_TYPE_NR:
1360 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1361 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1362 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1363 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1364 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1365 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1366 break;
1367 default:
1368 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse_1_1 invalid ratType");
1369 }
1370 }
1371 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1372 resultInfo_ = responseInfo;
1373 NotifyAll();
1374 return 0;
1375 }
1376
GetCurrentCellInfoResponse_1_2(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_2 & cellListCurrentInfo)1377 int32_t RilCallback::GetCurrentCellInfoResponse_1_2(
1378 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)
1379 {
1380 HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
1381 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1382 HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
1383 switch (static_cast<RatType>(info.ratType)) {
1384 case RatType::NETWORK_TYPE_LTE:
1385 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1386 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1387 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1388 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1389 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1390 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1391 break;
1392 case RatType::NETWORK_TYPE_GSM:
1393 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1394 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1395 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1396 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1397 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1398 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1399 break;
1400 case RatType::NETWORK_TYPE_WCDMA:
1401 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1402 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1403 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1404 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1405 break;
1406 case RatType::NETWORK_TYPE_NR:
1407 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1408 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1409 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1410 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1411 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1412 break;
1413 default:
1414 HDF_LOGE("invalid ratType");
1415 break;
1416 }
1417 }
1418 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1419 resultInfo_ = responseInfo;
1420 NotifyAll();
1421 return 0;
1422 }
1423
SetPreferredNetworkResponse(const RilRadioResponseInfo & responseInfo)1424 int32_t RilCallback::SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo)
1425 {
1426 HDF_LOGI("RilCallback::SetPreferredNetworkResponse error:%{public}d", responseInfo.error);
1427 hdiId_ = HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK;
1428 resultInfo_ = responseInfo;
1429 NotifyAll();
1430 return 0;
1431 }
1432
GetPreferredNetworkResponse(const RilRadioResponseInfo & responseInfo,const PreferredNetworkTypeInfo & preferredNetworkTypeInfo)1433 int32_t RilCallback::GetPreferredNetworkResponse(
1434 const RilRadioResponseInfo &responseInfo, const PreferredNetworkTypeInfo &preferredNetworkTypeInfo)
1435 {
1436 HDF_LOGI("RilCallback::GetPreferredNetworkResponse type:%{public}d", preferredNetworkTypeInfo.preferredNetworkType);
1437 hdiId_ = HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK;
1438 resultInfo_ = responseInfo;
1439 NotifyAll();
1440 return 0;
1441 }
1442
GetPhysicalChannelConfigResponse(const RilRadioResponseInfo & responseInfo,const ChannelConfigInfoList & channelConfigInfoList)1443 int32_t RilCallback::GetPhysicalChannelConfigResponse(
1444 const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList)
1445 {
1446 HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse itemNum:%{public}d", channelConfigInfoList.itemNum);
1447 for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
1448 HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse cellConnStatus:%{public}d, "
1449 "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
1450 "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
1451 "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
1452 phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
1453 phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
1454 phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
1455 for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
1456 HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
1457 }
1458 }
1459 hdiId_ = HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG;
1460 resultInfo_ = responseInfo;
1461 NotifyAll();
1462 return 0;
1463 }
1464
SetLocateUpdatesResponse(const RilRadioResponseInfo & responseInfo)1465 int32_t RilCallback::SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo)
1466 {
1467 HDF_LOGI("RilCallback::SetLocateUpdatesResponse error:%{public}d", responseInfo.error);
1468 hdiId_ = HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES;
1469 resultInfo_ = responseInfo;
1470 NotifyAll();
1471 return 0;
1472 }
1473
SetNotificationFilterResponse(const RilRadioResponseInfo & responseInfo)1474 int32_t RilCallback::SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo)
1475 {
1476 HDF_LOGI("RilCallback::SetNotificationFilterResponse error:%{public}d", responseInfo.error);
1477 hdiId_ = HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER;
1478 resultInfo_ = responseInfo;
1479 NotifyAll();
1480 return 0;
1481 }
1482
SetDeviceStateResponse(const RilRadioResponseInfo & responseInfo)1483 int32_t RilCallback::SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo)
1484 {
1485 HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1486 hdiId_ = HdiId::HREQ_NETWORK_SET_DEVICE_STATE;
1487 resultInfo_ = responseInfo;
1488 NotifyAll();
1489 return 0;
1490 }
1491
GetRrcConnectionStateResponse(const RilRadioResponseInfo & responseInfo,int32_t state)1492 int32_t RilCallback::GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1493 {
1494 HDF_LOGI("RilCallback::GetRrcConnectionStateResponse state:%{public}d", state);
1495 hdiId_ = HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE;
1496 resultInfo_ = responseInfo;
1497 NotifyAll();
1498 return 0;
1499 }
1500
SetNrOptionModeResponse(const RilRadioResponseInfo & responseInfo)1501 int32_t RilCallback::SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo)
1502 {
1503 HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1504 hdiId_ = HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE;
1505 resultInfo_ = responseInfo;
1506 NotifyAll();
1507 return 0;
1508 }
1509
GetNrOptionModeResponse(const RilRadioResponseInfo & responseInfo,int32_t state)1510 int32_t RilCallback::GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1511 {
1512 HDF_LOGI("RilCallback::GetNrOptionModeResponse state:%{public}d", state);
1513 hdiId_ = HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE;
1514 resultInfo_ = responseInfo;
1515 NotifyAll();
1516 return 0;
1517 }
1518
GetRrcConnectionStateUpdated(const RilRadioResponseInfo & responseInfo,int32_t state)1519 int32_t RilCallback::GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1520 {
1521 HDF_LOGI("RilCallback::GetRrcConnectionStateUpdated state:%{public}d", state);
1522 return 0;
1523 }
1524
GetNrSsbIdResponse(const RilRadioResponseInfo & responseInfo,const NrCellSsbIds & nrCellSsbIds)1525 int32_t RilCallback::GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds)
1526 {
1527 int32_t ssbListNum = 0;
1528 int32_t nbCellNum = 0;
1529 HDF_LOGE("rsrp:%{public}d", nrCellSsbIds.rsrp);
1530 HDF_LOGE("sinr:%{public}d", nrCellSsbIds.sinr);
1531 for (auto info : nrCellSsbIds.sCellSsbList) {
1532 ssbListNum = ssbListNum + 1;
1533 HDF_LOGE("sCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, info.rsrp);
1534 }
1535 HDF_LOGE("nbCellCount:%{public}d", nrCellSsbIds.nbCellCount);
1536 for (auto info : nrCellSsbIds.nbCellSsbList) {
1537 nbCellNum = nbCellNum + 1;
1538 HDF_LOGE("nbCellNum:%{public}d, rsrp:%{public}d, sinr:%{public}d", nbCellNum, info.rsrp, info.sinr);
1539 ssbListNum = 0;
1540 for (auto infoNbCell : info.ssbIdList) {
1541 ssbListNum = ssbListNum + 1;
1542 HDF_LOGE("nbCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, infoNbCell.rsrp);
1543 }
1544 }
1545 hdiId_ = HdiId::HREQ_NETWORK_GET_NR_SSBID_INFO;
1546 resultInfo_ = responseInfo;
1547 NotifyAll();
1548 return 0;
1549 }
1550
1551 // Call
CallEmergencyNotice(const RilRadioResponseInfo & responseInfo,const EmergencyInfoList & emergencyInfoList)1552 int32_t RilCallback::CallEmergencyNotice(
1553 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)
1554 {
1555 HDF_LOGI("GetBoolResult CallEmergencyNotice callSize : %{public}d", emergencyInfoList.callSize);
1556 return 0;
1557 }
1558
CallStateUpdated(const RilRadioResponseInfo & responseInfo)1559 int32_t RilCallback::CallStateUpdated(const RilRadioResponseInfo &responseInfo)
1560 {
1561 HDF_LOGI("GetBoolResult CallStateUpdated slotId : %{public}d, type: %{public}d", responseInfo.slotId,
1562 responseInfo.type);
1563 return 0;
1564 }
1565
CallRingbackVoiceNotice(const RilRadioResponseInfo & responseInfo,const RingbackVoice & ringbackVoice)1566 int32_t RilCallback::CallRingbackVoiceNotice(
1567 const RilRadioResponseInfo &responseInfo, const RingbackVoice &ringbackVoice)
1568 {
1569 HDF_LOGI("GetBoolResult CallRingbackVoiceNotice slotId : %{public}d, ringbackVoice: %{public}d",
1570 responseInfo.slotId, ringbackVoice.status);
1571 return 0;
1572 }
1573
CallSrvccStatusNotice(const RilRadioResponseInfo & responseInfo,const SrvccStatus & srvccStatus)1574 int32_t RilCallback::CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus)
1575 {
1576 HDF_LOGI("GetBoolResult CallSrvccStatusNotice slotId : %{public}d, srvccStatus: %{public}d",
1577 responseInfo.slotId, srvccStatus.status);
1578 return 0;
1579 }
1580
CallUssdNotice(const RilRadioResponseInfo & responseInfo,const UssdNoticeInfo & ussdNoticeInfo)1581 int32_t RilCallback::CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo)
1582 {
1583 HDF_LOGI("GetBoolResult CallUssdNotice slotId : %{public}d, ussdNoticeInfo m: %{public}d, str: %{public}s",
1584 responseInfo.slotId, ussdNoticeInfo.type, ussdNoticeInfo.message.c_str());
1585 return 0;
1586 }
1587
CallSsNotice(const RilRadioResponseInfo & responseInfo,const SsNoticeInfo & ssNoticeInfo)1588 int32_t RilCallback::CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo)
1589 {
1590 HDF_LOGI("GetBoolResult CallSsNotice slotId : %{public}d, result: %{public}d, serviceType: %{public}d,"
1591 "requestType: %{public}d, serviceClass: %{public}d", responseInfo.slotId, ssNoticeInfo.result,
1592 ssNoticeInfo.serviceType, ssNoticeInfo.requestType, ssNoticeInfo.serviceClass);
1593 return 0;
1594 }
1595
CallRsrvccStatusNotify(const RilRadioResponseInfo & responseInfo)1596 int32_t RilCallback::CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo)
1597 {
1598 HDF_LOGI("GetBoolResult CallRsrvccStatusNotify slotId : %{public}d", responseInfo.slotId);
1599 return 0;
1600 }
1601
GetEmergencyCallListResponse(const RilRadioResponseInfo & responseInfo,const EmergencyInfoList & emergencyInfoList)1602 int32_t RilCallback::GetEmergencyCallListResponse(
1603 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)
1604 {
1605 HDF_LOGI("GetBoolResult emergencyInfoList callSize : %{public}d", emergencyInfoList.callSize);
1606 hdiId_ = HdiId::HREQ_CALL_GET_EMERGENCY_LIST;
1607 resultInfo_ = responseInfo;
1608 NotifyAll();
1609 return 0;
1610 }
1611
SetEmergencyCallListResponse(const RilRadioResponseInfo & responseInfo)1612 int32_t RilCallback::SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo)
1613 {
1614 HDF_LOGI("GetBoolResult SetEmergencyCallListResponse");
1615 hdiId_ = HdiId::HREQ_CALL_SET_EMERGENCY_LIST;
1616 resultInfo_ = responseInfo;
1617 NotifyAll();
1618 return 0;
1619 }
1620
GetCallListResponse(const RilRadioResponseInfo & responseInfo,const CallInfoList & callList)1621 int32_t RilCallback::GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList)
1622 {
1623 HDF_LOGI("GetBoolResult CallInfoList callSize : %{public}d", callList.callSize);
1624 hdiId_ = HdiId::HREQ_CALL_GET_CALL_LIST;
1625 resultInfo_ = responseInfo;
1626 NotifyAll();
1627 return 0;
1628 }
1629
DialResponse(const RilRadioResponseInfo & responseInfo)1630 int32_t RilCallback::DialResponse(const RilRadioResponseInfo &responseInfo)
1631 {
1632 HDF_LOGI("GetBoolResult DialResponse");
1633 hdiId_ = HdiId::HREQ_CALL_DIAL;
1634 resultInfo_ = responseInfo;
1635 NotifyAll();
1636 return 0;
1637 }
1638
HangupResponse(const RilRadioResponseInfo & responseInfo)1639 int32_t RilCallback::HangupResponse(const RilRadioResponseInfo &responseInfo)
1640 {
1641 HDF_LOGI("GetBoolResult HangupResponse");
1642 hdiId_ = HdiId::HREQ_CALL_HANGUP;
1643 resultInfo_ = responseInfo;
1644 NotifyAll();
1645 return 0;
1646 }
1647
RejectResponse(const RilRadioResponseInfo & responseInfo)1648 int32_t RilCallback::RejectResponse(const RilRadioResponseInfo &responseInfo)
1649 {
1650 HDF_LOGI("GetBoolResult RejectResponse");
1651 hdiId_ = HdiId::HREQ_CALL_REJECT;
1652 resultInfo_ = responseInfo;
1653 NotifyAll();
1654 return 0;
1655 }
1656
AnswerResponse(const RilRadioResponseInfo & responseInfo)1657 int32_t RilCallback::AnswerResponse(const RilRadioResponseInfo &responseInfo)
1658 {
1659 HDF_LOGI("GetBoolResult AnswerResponse");
1660 hdiId_ = HdiId::HREQ_CALL_ANSWER;
1661 resultInfo_ = responseInfo;
1662 NotifyAll();
1663 return 0;
1664 }
1665
HoldCallResponse(const RilRadioResponseInfo & responseInfo)1666 int32_t RilCallback::HoldCallResponse(const RilRadioResponseInfo &responseInfo)
1667 {
1668 HDF_LOGI("GetBoolResult HoldCallResponse");
1669 hdiId_ = HdiId::HREQ_CALL_HOLD_CALL;
1670 resultInfo_ = responseInfo;
1671 NotifyAll();
1672 return 0;
1673 }
1674
UnHoldCallResponse(const RilRadioResponseInfo & responseInfo)1675 int32_t RilCallback::UnHoldCallResponse(const RilRadioResponseInfo &responseInfo)
1676 {
1677 HDF_LOGI("GetBoolResult UnHoldCallResponse");
1678 hdiId_ = HdiId::HREQ_CALL_UNHOLD_CALL;
1679 resultInfo_ = responseInfo;
1680 NotifyAll();
1681 return 0;
1682 }
1683
SwitchCallResponse(const RilRadioResponseInfo & responseInfo)1684 int32_t RilCallback::SwitchCallResponse(const RilRadioResponseInfo &responseInfo)
1685 {
1686 HDF_LOGI("GetBoolResult SwitchCallResponse");
1687 hdiId_ = HdiId::HREQ_CALL_SWITCH_CALL;
1688 resultInfo_ = responseInfo;
1689 NotifyAll();
1690 return 0;
1691 }
1692
GetClipResponse(const RilRadioResponseInfo & responseInfo,const GetClipResult & getClipResult)1693 int32_t RilCallback::GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult)
1694 {
1695 HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clipStat: %{public}d", getClipResult.result,
1696 getClipResult.action, getClipResult.clipStat);
1697 hdiId_ = HdiId::HREQ_CALL_GET_CLIP;
1698 resultInfo_ = responseInfo;
1699 NotifyAll();
1700 return 0;
1701 }
1702
SetClipResponse(const RilRadioResponseInfo & responseInfo)1703 int32_t RilCallback::SetClipResponse(const RilRadioResponseInfo &responseInfo)
1704 {
1705 HDF_LOGI("GetBoolResult SetClipResponse");
1706 hdiId_ = HdiId::HREQ_CALL_SET_CLIP;
1707 resultInfo_ = responseInfo;
1708 NotifyAll();
1709 return 0;
1710 }
1711
CombineConferenceResponse(const RilRadioResponseInfo & responseInfo)1712 int32_t RilCallback::CombineConferenceResponse(const RilRadioResponseInfo &responseInfo)
1713 {
1714 HDF_LOGI("GetBoolResult CombineConferenceResponse");
1715 hdiId_ = HdiId::HREQ_CALL_COMBINE_CONFERENCE;
1716 resultInfo_ = responseInfo;
1717 NotifyAll();
1718 return 0;
1719 }
1720
SeparateConferenceResponse(const RilRadioResponseInfo & responseInfo)1721 int32_t RilCallback::SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo)
1722 {
1723 HDF_LOGI("GetBoolResult SeparateConferenceResponse");
1724 hdiId_ = HdiId::HREQ_CALL_SEPARATE_CONFERENCE;
1725 resultInfo_ = responseInfo;
1726 NotifyAll();
1727 return 0;
1728 }
1729
CallSupplementResponse(const RilRadioResponseInfo & responseInfo)1730 int32_t RilCallback::CallSupplementResponse(const RilRadioResponseInfo &responseInfo)
1731 {
1732 HDF_LOGI("GetBoolResult CallSupplementResponse");
1733 hdiId_ = HdiId::HREQ_CALL_CALL_SUPPLEMENT;
1734 resultInfo_ = responseInfo;
1735 NotifyAll();
1736 return 0;
1737 }
1738
GetCallWaitingResponse(const RilRadioResponseInfo & responseInfo,const CallWaitResult & callWaitResult)1739 int32_t RilCallback::GetCallWaitingResponse(
1740 const RilRadioResponseInfo &responseInfo, const CallWaitResult &callWaitResult)
1741 {
1742 HDF_LOGI("GetBoolResult GetCallWaitingResponse result: %{public}d, status: %{public}d, classCw: %{public}d",
1743 callWaitResult.result, callWaitResult.status, callWaitResult.classCw);
1744 hdiId_ = HdiId::HREQ_CALL_GET_CALL_WAITING;
1745 resultInfo_ = responseInfo;
1746 NotifyAll();
1747 return 0;
1748 }
1749
SetCallWaitingResponse(const RilRadioResponseInfo & responseInfo)1750 int32_t RilCallback::SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo)
1751 {
1752 HDF_LOGI("GetBoolResult SetCallWaitingResponse");
1753 hdiId_ = HdiId::HREQ_CALL_SET_CALL_WAITING;
1754 resultInfo_ = responseInfo;
1755 NotifyAll();
1756 return 0;
1757 }
1758
GetCallTransferInfoResponse(const RilRadioResponseInfo & responseInfo,const CallForwardQueryInfoList & cFQueryList)1759 int32_t RilCallback::GetCallTransferInfoResponse(
1760 const RilRadioResponseInfo &responseInfo, const CallForwardQueryInfoList &cFQueryList)
1761 {
1762 HDF_LOGI("GetBoolResult GetCallTransferInfoResponse cFQueryList: %{public}d", cFQueryList.callSize);
1763 hdiId_ = HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO;
1764 resultInfo_ = responseInfo;
1765 NotifyAll();
1766 return 0;
1767 }
1768
SetCallTransferInfoResponse(const RilRadioResponseInfo & responseInfo)1769 int32_t RilCallback::SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo)
1770 {
1771 HDF_LOGI("GetBoolResult SetCallTransferInfoResponse");
1772 hdiId_ = HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO;
1773 resultInfo_ = responseInfo;
1774 NotifyAll();
1775 return 0;
1776 }
1777
GetCallRestrictionResponse(const RilRadioResponseInfo & responseInfo,const CallRestrictionResult & result)1778 int32_t RilCallback::GetCallRestrictionResponse(
1779 const RilRadioResponseInfo &responseInfo, const CallRestrictionResult &result)
1780 {
1781 HDF_LOGI("GetBoolResult result: %{public}d, status: %{public}d, classCw: %{public}d", result.result, result.status,
1782 result.classCw);
1783 hdiId_ = HdiId::HREQ_CALL_GET_CALL_RESTRICTION;
1784 resultInfo_ = responseInfo;
1785 NotifyAll();
1786 return 0;
1787 }
SetCallRestrictionResponse(const RilRadioResponseInfo & responseInfo)1788 int32_t RilCallback::SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo)
1789 {
1790 HDF_LOGI("GetBoolResult SetCallRestrictionResponse");
1791 hdiId_ = HdiId::HREQ_CALL_SET_CALL_RESTRICTION;
1792 resultInfo_ = responseInfo;
1793 NotifyAll();
1794 return 0;
1795 }
GetClirResponse(const RilRadioResponseInfo & responseInfo,const GetClirResult & getClirResult)1796 int32_t RilCallback::GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult)
1797 {
1798 HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clirStat: %{public}d", getClirResult.result,
1799 getClirResult.action, getClirResult.clirStat);
1800 hdiId_ = HdiId::HREQ_CALL_GET_CLIR;
1801 resultInfo_ = responseInfo;
1802 NotifyAll();
1803 return 0;
1804 }
1805
SetClirResponse(const RilRadioResponseInfo & responseInfo)1806 int32_t RilCallback::SetClirResponse(const RilRadioResponseInfo &responseInfo)
1807 {
1808 HDF_LOGI("GetBoolResult SetClirResponse");
1809 hdiId_ = HdiId::HREQ_CALL_SET_CLIR;
1810 resultInfo_ = responseInfo;
1811 NotifyAll();
1812 return 0;
1813 }
1814
StartDtmfResponse(const RilRadioResponseInfo & responseInfo)1815 int32_t RilCallback::StartDtmfResponse(const RilRadioResponseInfo &responseInfo)
1816 {
1817 HDF_LOGI("GetBoolResult StartDtmfResponse");
1818 hdiId_ = HdiId::HREQ_CALL_START_DTMF;
1819 resultInfo_ = responseInfo;
1820 NotifyAll();
1821 return 0;
1822 }
1823
SendDtmfResponse(const RilRadioResponseInfo & responseInfo)1824 int32_t RilCallback::SendDtmfResponse(const RilRadioResponseInfo &responseInfo)
1825 {
1826 HDF_LOGI("GetBoolResult SendDtmfResponse");
1827 hdiId_ = HdiId::HREQ_CALL_SEND_DTMF;
1828 resultInfo_ = responseInfo;
1829 NotifyAll();
1830 return 0;
1831 }
1832
StopDtmfResponse(const RilRadioResponseInfo & responseInfo)1833 int32_t RilCallback::StopDtmfResponse(const RilRadioResponseInfo &responseInfo)
1834 {
1835 HDF_LOGI("GetBoolResult StopDtmfResponse");
1836 hdiId_ = HdiId::HREQ_CALL_STOP_DTMF;
1837 resultInfo_ = responseInfo;
1838 NotifyAll();
1839 return 0;
1840 }
1841
GetCallPreferenceModeResponse(const RilRadioResponseInfo & responseInfo,int32_t mode)1842 int32_t RilCallback::GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode)
1843 {
1844 HDF_LOGI("GetBoolResult GetCallPreferenceModeResponse mode: %{public}d", mode);
1845 hdiId_ = HdiId::HREQ_CALL_GET_CALL_PREFERENCE;
1846 resultInfo_ = responseInfo;
1847 NotifyAll();
1848 return 0;
1849 }
1850
SetCallPreferenceModeResponse(const RilRadioResponseInfo & responseInfo)1851 int32_t RilCallback::SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo)
1852 {
1853 HDF_LOGI("GetBoolResult SetCallPreferenceModeResponse");
1854 hdiId_ = HdiId::HREQ_CALL_SET_CALL_PREFERENCE;
1855 resultInfo_ = responseInfo;
1856 NotifyAll();
1857 return 0;
1858 }
1859
SetUssdResponse(const RilRadioResponseInfo & responseInfo)1860 int32_t RilCallback::SetUssdResponse(const RilRadioResponseInfo &responseInfo)
1861 {
1862 HDF_LOGI("GetBoolResult SetUssdResponse");
1863 hdiId_ = HdiId::HREQ_CALL_SET_USSD;
1864 resultInfo_ = responseInfo;
1865 NotifyAll();
1866 return 0;
1867 }
1868
GetUssdResponse(const RilRadioResponseInfo & responseInfo,int32_t cusd)1869 int32_t RilCallback::GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd)
1870 {
1871 HDF_LOGI("GetBoolResult GetUssdResponse cusd: %{public}d", cusd);
1872 hdiId_ = HdiId::HREQ_CALL_GET_USSD;
1873 resultInfo_ = responseInfo;
1874 NotifyAll();
1875 return 0;
1876 }
1877
SetMuteResponse(const RilRadioResponseInfo & responseInfo)1878 int32_t RilCallback::SetMuteResponse(const RilRadioResponseInfo &responseInfo)
1879 {
1880 HDF_LOGI("GetBoolResult SetMuteResponse");
1881 hdiId_ = HdiId::HREQ_CALL_SET_MUTE;
1882 resultInfo_ = responseInfo;
1883 NotifyAll();
1884 return 0;
1885 }
1886
GetMuteResponse(const RilRadioResponseInfo & responseInfo,int32_t mute)1887 int32_t RilCallback::GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute)
1888 {
1889 HDF_LOGI("GetBoolResult GetMuteResponse mute: %{public}d", mute);
1890 hdiId_ = HdiId::HREQ_CALL_GET_MUTE;
1891 resultInfo_ = responseInfo;
1892 NotifyAll();
1893 return 0;
1894 }
1895
GetCallFailReasonResponse(const RilRadioResponseInfo & responseInfo,int32_t callFail)1896 int32_t RilCallback::GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail)
1897 {
1898 HDF_LOGI("GetBoolResult GetCallFailReasonResponse callFail: %{public}d", callFail);
1899 hdiId_ = HdiId::HREQ_CALL_GET_FAIL_REASON;
1900 resultInfo_ = responseInfo;
1901 NotifyAll();
1902 return 0;
1903 }
1904
SetBarringPasswordResponse(const RilRadioResponseInfo & responseInfo)1905 int32_t RilCallback::SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo)
1906 {
1907 HDF_LOGI("GetBoolResult SetBarringPasswordResponse");
1908 hdiId_ = HdiId::HREQ_CALL_SET_BARRING_PASSWORD;
1909 resultInfo_ = responseInfo;
1910 NotifyAll();
1911 return 0;
1912 }
1913
CloseUnFinishedUssdResponse(const RilRadioResponseInfo & responseInfo)1914 int32_t RilCallback::CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo)
1915 {
1916 HDF_LOGI("GetBoolResult CloseUnFinishedUssdResponse");
1917 hdiId_ = HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD;
1918 resultInfo_ = responseInfo;
1919 NotifyAll();
1920 return 0;
1921 }
1922
SetVonrSwitchResponse(const RilRadioResponseInfo & responseInfo)1923 int32_t RilCallback::SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo)
1924 {
1925 HDF_LOGI("GetBoolResult SetVonrSwitchResponse");
1926 hdiId_ = HdiId::HREQ_SET_VONR_SWITCH;
1927 resultInfo_ = responseInfo;
1928 NotifyAll();
1929 return 0;
1930 }
1931
1932 /**
1933 * modem
1934 **/
RadioStateUpdated(const RilRadioResponseInfo & responseInfo,int32_t state)1935 int32_t RilCallback::RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1936 {
1937 HDF_LOGI("RadioStateUpdated state : %{public}d", state);
1938 return 0;
1939 }
1940
VoiceRadioTechUpdated(const RilRadioResponseInfo & responseInfo,const VoiceRadioTechnology & voiceRadioTechnology)1941 int32_t RilCallback::VoiceRadioTechUpdated(
1942 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)
1943 {
1944 HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
1945 "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
1946 "%{public}s actName : %{public}s",
1947 voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
1948 voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
1949 voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(), voiceRadioTechnology.actName.c_str());
1950 return 0;
1951 }
1952
DsdsModeUpdated(const RilRadioResponseInfo & responseInfo,int32_t mode)1953 int32_t RilCallback::DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode)
1954 {
1955 HDF_LOGI("DsdsModeUpdated mode : %{public}d", mode);
1956 return 0;
1957 }
1958
NcfgFinishedResult(const RilRadioResponseInfo & responseInfo,int32_t state)1959 int32_t RilCallback::NcfgFinishedResult(const RilRadioResponseInfo &responseInfo, int32_t state)
1960 {
1961 HDF_LOGI("DsdsModeUpdated state : %{public}d", state);
1962 return 0;
1963 }
1964
RestartRildNvMatch(const RilRadioResponseInfo & responseInfo,int32_t state)1965 int32_t RilCallback::RestartRildNvMatch(const RilRadioResponseInfo &responseInfo, int32_t state)
1966 {
1967 HDF_LOGI("DsdsModeUpdated state : %{public}d", state);
1968 return 0;
1969 }
1970
NetworkSliceUrspRpt(const RilRadioResponseInfo & responseInfo,const NetworkSliceUrspInfo & networkSliceUrspInfo)1971 int32_t RilCallback::NetworkSliceUrspRpt(const RilRadioResponseInfo &responseInfo,
1972 const NetworkSliceUrspInfo &networkSliceUrspInfo)
1973 {
1974 HDF_LOGI("NetworkSliceUrspRpt");
1975 return 0;
1976 }
NetworkSliceAllowedNssaiRpt(const RilRadioResponseInfo & responseInfo,const NetworkSliceAllowedNssaiInfo & networkSliceAllowedNssaiInfo)1977 int32_t RilCallback::NetworkSliceAllowedNssaiRpt(const RilRadioResponseInfo &responseInfo,
1978 const NetworkSliceAllowedNssaiInfo &networkSliceAllowedNssaiInfo)
1979 {
1980 HDF_LOGI("NetworkSliceAllowedNssaiRpt");
1981 return 0;
1982 }
NetworkSliceEhplmnRpt(const RilRadioResponseInfo & responseInfo,const NetworkSliceEhplmnInfo & networkSliceEhplmnInfo)1983 int32_t RilCallback::NetworkSliceEhplmnRpt(const RilRadioResponseInfo &responseInfo,
1984 const NetworkSliceEhplmnInfo &networkSliceEhplmnInfo)
1985 {
1986 HDF_LOGI("NetworkSliceEhplmnRpt");
1987 return 0;
1988 }
1989
ShutDownResponse(const RilRadioResponseInfo & responseInfo)1990 int32_t RilCallback::ShutDownResponse(const RilRadioResponseInfo &responseInfo)
1991 {
1992 HDF_LOGI("ShutDownResponse");
1993 hdiId_ = HdiId::HREQ_MODEM_SHUT_DOWN;
1994 resultInfo_ = responseInfo;
1995 NotifyAll();
1996 return 0;
1997 }
1998
SetRadioStateResponse(const RilRadioResponseInfo & responseInfo)1999 int32_t RilCallback::SetRadioStateResponse(const RilRadioResponseInfo &responseInfo)
2000 {
2001 HDF_LOGI("SetRadioStateResponse");
2002 hdiId_ = HdiId::HREQ_MODEM_SET_RADIO_STATUS;
2003 resultInfo_ = responseInfo;
2004 NotifyAll();
2005 return 0;
2006 }
2007
GetRadioStateResponse(const RilRadioResponseInfo & responseInfo,int32_t state)2008 int32_t RilCallback::GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
2009 {
2010 HDF_LOGI("GetRadioStateResponse state : %{public}d", state);
2011 hdiId_ = HdiId::HREQ_MODEM_GET_RADIO_STATUS;
2012 resultInfo_ = responseInfo;
2013 NotifyAll();
2014 return 0;
2015 }
2016
GetImeiResponse(const RilRadioResponseInfo & responseInfo,const std::string & imei)2017 int32_t RilCallback::GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei)
2018 {
2019 HDF_LOGI("GetImeiResponse imei : %{public}s", imei.c_str());
2020 hdiId_ = HdiId::HREQ_MODEM_GET_IMEI;
2021 resultInfo_ = responseInfo;
2022 NotifyAll();
2023 return 0;
2024 }
2025
GetImeiSvResponse(const RilRadioResponseInfo & responseInfo,const std::string & imeiSv)2026 int32_t RilCallback::GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv)
2027 {
2028 hdiId_ = HdiId::HREQ_MODEM_GET_IMEISV;
2029 resultInfo_ = responseInfo;
2030 NotifyAll();
2031 return 0;
2032 }
2033
GetMeidResponse(const RilRadioResponseInfo & responseInfo,const std::string & meid)2034 int32_t RilCallback::GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid)
2035 {
2036 HDF_LOGI("GetMeidResponse meid : %{public}s", meid.c_str());
2037 hdiId_ = HdiId::HREQ_MODEM_GET_MEID;
2038 resultInfo_ = responseInfo;
2039 NotifyAll();
2040 return 0;
2041 }
2042
GetVoiceRadioTechnologyResponse(const RilRadioResponseInfo & responseInfo,const VoiceRadioTechnology & voiceRadioTechnology)2043 int32_t RilCallback::GetVoiceRadioTechnologyResponse(
2044 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)
2045 {
2046 HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
2047 "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
2048 "%{public}s actName : %{public}s",
2049 voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
2050 voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
2051 voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(), voiceRadioTechnology.actName.c_str());
2052 hdiId_ = HdiId::HREQ_MODEM_GET_VOICE_RADIO;
2053 resultInfo_ = responseInfo;
2054 NotifyAll();
2055 return 0;
2056 }
2057
GetBasebandVersionResponse(const RilRadioResponseInfo & responseInfo,const std::string & basebandVersion)2058 int32_t RilCallback::GetBasebandVersionResponse(
2059 const RilRadioResponseInfo &responseInfo, const std::string &basebandVersion)
2060 {
2061 HDF_LOGI("GetBasebandVersionResponse basebandVersion : %{public}s", basebandVersion.c_str());
2062 hdiId_ = HdiId::HREQ_MODEM_GET_BASEBAND_VERSION;
2063 resultInfo_ = responseInfo;
2064 NotifyAll();
2065 return 0;
2066 }
2067
2068 // Data
PdpContextListUpdated(const RilRadioResponseInfo & responseInfo,const DataCallResultList & dataCallResultList)2069 int32_t RilCallback::PdpContextListUpdated(
2070 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)
2071 {
2072 HDF_LOGI("RilCallback::PdpContextListUpdated size:%{public}d", dataCallResultList.size);
2073 for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
2074 HDF_LOGI(
2075 "RilCallback::PdpContextListUpdated flag:%{public}d reason:%{public}d retryTime:%{public}d "
2076 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2077 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2078 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2079 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2080 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2081 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2082 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2083 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2084 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2085 setupDataCallResultInfo.pduSessionId);
2086 }
2087 return 0;
2088 }
2089
DataLinkCapabilityUpdated(const RilRadioResponseInfo & responseInfo,const DataLinkCapability & dataLinkCapability)2090 int32_t RilCallback::DataLinkCapabilityUpdated(
2091 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)
2092 {
2093 HDF_LOGI(
2094 "RilCallback::DataLinkCapabilityUpdated primaryDownlinkKbps:%{public}d primaryUplinkKbps:%{public}d "
2095 "secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
2096 dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
2097 dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
2098 return 0;
2099 }
2100
ActivatePdpContextResponse(const RilRadioResponseInfo & responseInfo,const SetupDataCallResultInfo & setupDataCallResultInfo)2101 int32_t RilCallback::ActivatePdpContextResponse(
2102 const RilRadioResponseInfo &responseInfo, const SetupDataCallResultInfo &setupDataCallResultInfo)
2103 {
2104 HDF_LOGI("RilCallback::ActivatePdpContextResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
2105 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2106 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2107 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2108 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2109 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2110 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2111 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2112 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2113 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2114 setupDataCallResultInfo.pduSessionId);
2115 hdiId_ = HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT;
2116 resultInfo_ = responseInfo;
2117 NotifyAll();
2118 return 0;
2119 }
2120
DeactivatePdpContextResponse(const RilRadioResponseInfo & responseInfo)2121 int32_t RilCallback::DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo)
2122 {
2123 HDF_LOGI("RilCallback::DeactivatePdpContextResponse error:%{public}d", responseInfo.error);
2124 hdiId_ = HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT;
2125 resultInfo_ = responseInfo;
2126 NotifyAll();
2127 return 0;
2128 }
2129
GetPdpContextListResponse(const RilRadioResponseInfo & responseInfo,const DataCallResultList & dataCallResultList)2130 int32_t RilCallback::GetPdpContextListResponse(
2131 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)
2132 {
2133 HDF_LOGI("RilCallback::GetPdpContextListResponse size:%{public}d", dataCallResultList.size);
2134 for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
2135 HDF_LOGI(
2136 "RilCallback::GetPdpContextListResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
2137 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2138 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2139 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2140 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2141 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2142 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2143 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2144 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2145 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2146 setupDataCallResultInfo.pduSessionId);
2147 }
2148 hdiId_ = HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST;
2149 resultInfo_ = responseInfo;
2150 NotifyAll();
2151 return 0;
2152 }
2153
SetInitApnInfoResponse(const RilRadioResponseInfo & responseInfo)2154 int32_t RilCallback::SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo)
2155 {
2156 HDF_LOGI("RilCallback::SetInitApnInfoResponse error:%{public}d", responseInfo.error);
2157 hdiId_ = HdiId::HREQ_DATA_SET_INIT_APN_INFO;
2158 resultInfo_ = responseInfo;
2159 NotifyAll();
2160 return 0;
2161 }
2162
SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo & responseInfo)2163 int32_t RilCallback::SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo)
2164 {
2165 HDF_LOGI("RilCallback::SetLinkBandwidthReportingRuleResponse error:%{public}d", responseInfo.error);
2166 hdiId_ = HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE;
2167 resultInfo_ = responseInfo;
2168 NotifyAll();
2169 return 0;
2170 }
2171
GetLinkBandwidthInfoResponse(const RilRadioResponseInfo & responseInfo,const DataLinkBandwidthInfo & dataLinkBandwidthInfo)2172 int32_t RilCallback::GetLinkBandwidthInfoResponse(
2173 const RilRadioResponseInfo &responseInfo, const DataLinkBandwidthInfo &dataLinkBandwidthInfo)
2174 {
2175 HDF_LOGI(
2176 "RilCallback::GetLinkBandwidthInfoResponse serial:%{public}d cid:%{public}d qi:%{public}d dlGfbr:%{public}d "
2177 "ulGfbr:%{public}d dlMfbr:%{public}d ulMfbr:%{public}d ulSambr:%{public}d dlSambr:%{public}d "
2178 "averagingWindow:%{public}d",
2179 dataLinkBandwidthInfo.serial, dataLinkBandwidthInfo.cid, dataLinkBandwidthInfo.qi, dataLinkBandwidthInfo.dlGfbr,
2180 dataLinkBandwidthInfo.ulGfbr, dataLinkBandwidthInfo.dlMfbr, dataLinkBandwidthInfo.ulMfbr,
2181 dataLinkBandwidthInfo.ulSambr, dataLinkBandwidthInfo.dlSambr, dataLinkBandwidthInfo.averagingWindow);
2182 hdiId_ = HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO;
2183 resultInfo_ = responseInfo;
2184 NotifyAll();
2185 return 0;
2186 }
2187
SetDataPermittedResponse(const RilRadioResponseInfo & responseInfo)2188 int32_t RilCallback::SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo)
2189 {
2190 HDF_LOGI("RilCallback::SetDataPermittedResponse error:%{public}d", responseInfo.error);
2191 hdiId_ = HdiId::HREQ_DATA_SET_DATA_PERMITTED;
2192 resultInfo_ = responseInfo;
2193 NotifyAll();
2194 return 0;
2195 }
2196
SetDataProfileInfoResponse(const RilRadioResponseInfo & responseInfo)2197 int32_t RilCallback::SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo)
2198 {
2199 HDF_LOGI("RilCallback::SetDataProfileInfoResponse error:%{public}d", responseInfo.error);
2200 hdiId_ = HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO;
2201 resultInfo_ = responseInfo;
2202 NotifyAll();
2203 return 0;
2204 }
2205
GetLinkCapabilityResponse(const RilRadioResponseInfo & responseInfo,const DataLinkCapability & dataLinkCapability)2206 int32_t RilCallback::GetLinkCapabilityResponse(
2207 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)
2208 {
2209 HDF_LOGI(
2210 "RilCallbackTest::GetLinkCapabilityResponse primaryDownlinkKbps:%{public}d "
2211 "primaryUplinkKbps:%{public}d secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
2212 dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
2213 dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
2214 hdiId_ = HdiId::HREQ_DATA_GET_LINK_CAPABILITY;
2215 resultInfo_ = responseInfo;
2216 NotifyAll();
2217 return 0;
2218 }
2219
CleanAllConnectionsResponse(const RilRadioResponseInfo & responseInfo)2220 int32_t RilCallback::CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo)
2221 {
2222 HDF_LOGI("RilCallback::CleanAllConnectionsResponse error:%{public}d", responseInfo.error);
2223 hdiId_ = HdiId::HREQ_DATA_CLEAN_ALL_CONNECTIONS;
2224 resultInfo_ = responseInfo;
2225 NotifyAll();
2226 return 0;
2227 }
2228 // Sms
NewSmsNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2229 int32_t RilCallback::NewSmsNotify(
2230 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2231 {
2232 HDF_LOGI("RilCallback::NewSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2233 return 0;
2234 }
2235
NewCdmaSmsNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2236 int32_t RilCallback::NewCdmaSmsNotify(
2237 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2238 {
2239 HDF_LOGI("RilCallback::NewCdmaSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2240 return 0;
2241 }
2242
SmsStatusReportNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2243 int32_t RilCallback::SmsStatusReportNotify(
2244 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2245 {
2246 HDF_LOGI("RilCallback::SmsStatusReportNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2247 return 0;
2248 }
2249
NewSmsStoredOnSimNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,int32_t recordNumber,int32_t indicationType)2250 int32_t RilCallback::NewSmsStoredOnSimNotify(
2251 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t recordNumber, int32_t indicationType)
2252 {
2253 HDF_LOGI("RilCallback::NewSmsStoredOnSimNotify recordNumber : %{public}d, indicationType : %{public}d",
2254 recordNumber, indicationType);
2255 return 0;
2256 }
2257
CBConfigNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const CBConfigReportInfo & cellBroadConfigReportInfo)2258 int32_t RilCallback::CBConfigNotify(
2259 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const CBConfigReportInfo &cellBroadConfigReportInfo)
2260 {
2261 HDF_LOGI("RilCallback::CBConfigNotify cellBroadConfigReportInfo dcs : %{public}s",
2262 cellBroadConfigReportInfo.dcs.c_str());
2263 return 0;
2264 }
2265
SendGsmSmsResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2266 int32_t RilCallback::SendGsmSmsResponse(
2267 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2268 {
2269 HDF_LOGI("RilCallback::SendGsmSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2270 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2271 hdiId_ = HdiId::HREQ_SMS_SEND_GSM_SMS;
2272 resultInfo_ = responseInfo;
2273 NotifyAll();
2274 return 0;
2275 }
2276
SendCdmaSmsResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2277 int32_t RilCallback::SendCdmaSmsResponse(
2278 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2279 {
2280 HDF_LOGI("RilCallback::SendCdmaSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2281 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2282 hdiId_ = HdiId::HREQ_SMS_SEND_CDMA_SMS;
2283 resultInfo_ = responseInfo;
2284 NotifyAll();
2285 return 0;
2286 }
2287
AddSimMessageResponse(const RilRadioResponseInfo & responseInfo)2288 int32_t RilCallback::AddSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2289 {
2290 HDF_LOGI("RilCallback::AddSimMessageResponse error : %{public}d", responseInfo.error);
2291 hdiId_ = HdiId::HREQ_SMS_ADD_SIM_MESSAGE;
2292 resultInfo_ = responseInfo;
2293 NotifyAll();
2294 return 0;
2295 }
2296
DelSimMessageResponse(const RilRadioResponseInfo & responseInfo)2297 int32_t RilCallback::DelSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2298 {
2299 HDF_LOGI("RilCallback::DelSimMessageResponse error : %{public}d", responseInfo.error);
2300 hdiId_ = HdiId::HREQ_SMS_DEL_SIM_MESSAGE;
2301 resultInfo_ = responseInfo;
2302 NotifyAll();
2303 return 0;
2304 }
UpdateSimMessageResponse(const RilRadioResponseInfo & responseInfo)2305 int32_t RilCallback::UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2306 {
2307 HDF_LOGI("RilCallback::UpdateSimMessageResponse error : %{public}d", responseInfo.error);
2308 hdiId_ = HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE;
2309 resultInfo_ = responseInfo;
2310 NotifyAll();
2311 return 0;
2312 }
2313
AddCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2314 int32_t RilCallback::AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2315 {
2316 HDF_LOGI("RilCallback::AddCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2317 hdiId_ = HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE;
2318 resultInfo_ = responseInfo;
2319 NotifyAll();
2320 return 0;
2321 }
2322
DelCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2323 int32_t RilCallback::DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2324 {
2325 HDF_LOGI("RilCallback::DelCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2326 hdiId_ = HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE;
2327 resultInfo_ = responseInfo;
2328 NotifyAll();
2329 return 0;
2330 }
2331
UpdateCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2332 int32_t RilCallback::UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2333 {
2334 HDF_LOGI("RilCallback::UpdateCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2335 hdiId_ = HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE;
2336 resultInfo_ = responseInfo;
2337 NotifyAll();
2338 return 0;
2339 }
2340
SetSmscAddrResponse(const RilRadioResponseInfo & responseInfo)2341 int32_t RilCallback::SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo)
2342 {
2343 HDF_LOGI("RilCallback::SetSmscAddrResponse error : %{public}d", responseInfo.error);
2344 hdiId_ = HdiId::HREQ_SMS_SET_SMSC_ADDR;
2345 resultInfo_ = responseInfo;
2346 NotifyAll();
2347 return 0;
2348 }
2349
GetSmscAddrResponse(const RilRadioResponseInfo & responseInfo,const ServiceCenterAddress & serviceCenterAddress)2350 int32_t RilCallback::GetSmscAddrResponse(
2351 const RilRadioResponseInfo &responseInfo, const ServiceCenterAddress &serviceCenterAddress)
2352 {
2353 HDF_LOGI("RilCallback::GetSmscAddrResponse serviceCenterAddress tosca : %{public}d, address : %{public}s",
2354 serviceCenterAddress.tosca, serviceCenterAddress.address.c_str());
2355 hdiId_ = HdiId::HREQ_SMS_GET_SMSC_ADDR;
2356 resultInfo_ = responseInfo;
2357 NotifyAll();
2358 return 0;
2359 }
2360
SetCBConfigResponse(const RilRadioResponseInfo & responseInfo)2361 int32_t RilCallback::SetCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2362 {
2363 HDF_LOGI("RilCallback::SetCBConfigResponse error : %{public}d", responseInfo.error);
2364 hdiId_ = HdiId::HREQ_SMS_SET_CB_CONFIG;
2365 resultInfo_ = responseInfo;
2366 NotifyAll();
2367 return 0;
2368 }
2369
GetCBConfigResponse(const RilRadioResponseInfo & responseInfo,const CBConfigInfo & cellBroadcastInfo)2370 int32_t RilCallback::GetCBConfigResponse(
2371 const RilRadioResponseInfo &responseInfo, const CBConfigInfo &cellBroadcastInfo)
2372 {
2373 HDF_LOGI("RilCallback::GetCBConfigResponse cellBroadcastInfo mids : %{public}s, dcss: %{public}s",
2374 cellBroadcastInfo.mids.c_str(), cellBroadcastInfo.dcss.c_str());
2375 hdiId_ = HdiId::HREQ_SMS_GET_CB_CONFIG;
2376 resultInfo_ = responseInfo;
2377 NotifyAll();
2378 return 0;
2379 }
2380
SetCdmaCBConfigResponse(const RilRadioResponseInfo & responseInfo)2381 int32_t RilCallback::SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2382 {
2383 HDF_LOGI("RilCallback::SetCdmaCBConfigResponse error : %{public}d", responseInfo.error);
2384 hdiId_ = HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG;
2385 resultInfo_ = responseInfo;
2386 NotifyAll();
2387 return 0;
2388 }
2389
GetCdmaCBConfigResponse(const RilRadioResponseInfo & responseInfo,const CdmaCBConfigInfo & cdmaCBConfigInfo)2390 int32_t RilCallback::GetCdmaCBConfigResponse(
2391 const RilRadioResponseInfo &responseInfo, const CdmaCBConfigInfo &cdmaCBConfigInfo)
2392 {
2393 HDF_LOGI("RilCallback::GetCdmaCBConfigResponse cdmaCBConfigInfo service : %{public}d, language : %{public}d, "
2394 "checked: %{public}d",
2395 cdmaCBConfigInfo.service, cdmaCBConfigInfo.language, cdmaCBConfigInfo.checked);
2396 hdiId_ = HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG;
2397 resultInfo_ = responseInfo;
2398 NotifyAll();
2399 return 0;
2400 }
2401
SendSmsMoreModeResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2402 int32_t RilCallback::SendSmsMoreModeResponse(
2403 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2404 {
2405 HDF_LOGI("RilCallback::SendSmsMoreModeResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2406 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2407 hdiId_ = HdiId::HREQ_SMS_SEND_SMS_MORE_MODE;
2408 resultInfo_ = responseInfo;
2409 NotifyAll();
2410 return 0;
2411 }
2412
SendSmsAckResponse(const RilRadioResponseInfo & responseInfo)2413 int32_t RilCallback::SendSmsAckResponse(const RilRadioResponseInfo &responseInfo)
2414 {
2415 HDF_LOGI("RilCallback::SendSmsAckResponse error:%{public}d", responseInfo.error);
2416 hdiId_ = HdiId::HREQ_SMS_SEND_SMS_ACK;
2417 resultInfo_ = responseInfo;
2418 NotifyAll();
2419 return 0;
2420 }
2421
CommonErrorResponse(const RilRadioResponseInfo & responseInfo)2422 int32_t RilCallback::CommonErrorResponse(const RilRadioResponseInfo &responseInfo)
2423 {
2424 HDF_LOGI(
2425 "RilCallback::CommonErrorResponse type:%{public}d error:%{public}d", responseInfo.type, responseInfo.error);
2426 return 0;
2427 }
2428
GetCallListResponseExt(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const OHOS::HDI::Ril::V1_4::CallInfoExtList & callList)2429 int32_t RilCallback::GetCallListResponseExt(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo& responseInfo,
2430 const OHOS::HDI::Ril::V1_4::CallInfoExtList& callList)
2431 {
2432 return 0;
2433 }
2434
2435 /**
2436 ** HdfRilHdiTest implement
2437 **/
SetUpTestCase()2438 void HdfRilHdiTest::SetUpTestCase() {}
2439
TearDownTestCase()2440 void HdfRilHdiTest::TearDownTestCase() {}
2441
SetUp()2442 void HdfRilHdiTest::SetUp() {}
2443
TearDown()2444 void HdfRilHdiTest::TearDown() {}
2445
2446 /**
2447 ** Xts Test
2448 **/
2449
2450 HWTEST_F(HdfRilHdiTest, CheckRilInstanceIsEmpty, Function | MediumTest | Level1)
2451 {
2452 g_rilInterface = OHOS::HDI::Ril::V1_5::IRil::Get();
2453 if (g_rilInterface != nullptr) {
2454 g_rilInterface->SetCallback1_5(&callback_);
2455 }
2456 }
2457
2458 HWTEST_F(HdfRilHdiTest, SendRilAck, Function | MediumTest | Level1)
2459 {
2460 if (g_rilInterface == nullptr) {
2461 return;
2462 }
2463 int32_t ret = g_rilInterface->SendRilAck();
2464 EXPECT_EQ(SUCCESS, ret);
2465 }
2466
2467 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimStatus_V1_0100, Function | MediumTest | Level3)
2468 {
2469 if (g_rilInterface == nullptr) {
2470 return;
2471 }
2472 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
2473 if (ret != 2) {
2474 WaitFor(WAIT_TIME_SECOND);
2475 EXPECT_EQ(SUCCESS, ret);
2476 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
2477 } else {
2478 return;
2479 }
2480 }
2481
2482 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimStatus_V1_0200, Function | MediumTest | Level3)
2483 {
2484 if (g_rilInterface == nullptr) {
2485 return;
2486 }
2487 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_2, GetSerialId());
2488 if (ret != 2) {
2489 WaitFor(WAIT_TIME_SECOND);
2490 EXPECT_EQ(SUCCESS, ret);
2491 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
2492 } else {
2493 return;
2494 }
2495 }
2496
2497 // Call
2498 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetEmergencyCallList_V1_0100, Function | MediumTest | Level3)
2499 {
2500 if (!IsReady(SLOTID_1)) {
2501 return;
2502 }
2503 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, GetSerialId());
2504 WaitFor(WAIT_TIME_SECOND);
2505 EXPECT_EQ(SUCCESS, ret);
2506 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_EMERGENCY_LIST));
2507 }
2508
2509 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetEmergencyCallList_V1_0200, Function | MediumTest | Level3)
2510 {
2511 if (!IsReady(SLOTID_2)) {
2512 return;
2513 }
2514 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_2, GetSerialId());
2515 WaitFor(WAIT_TIME_SECOND);
2516 EXPECT_EQ(SUCCESS, ret);
2517 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_EMERGENCY_LIST));
2518 }
2519
2520 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetEmergencyCallList_V1_0100, Function | MediumTest | Level3)
2521 {
2522 if (!IsReady(SLOTID_1)) {
2523 return;
2524 }
2525 EmergencyInfoList emergencyInfoList;
2526 EmergencyCall emergencyInfo = {};
2527 emergencyInfo.index = 1;
2528 emergencyInfo.total = 1;
2529 emergencyInfo.eccNum = "120";
2530 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
2531 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
2532 emergencyInfo.mcc = "460";
2533 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
2534 emergencyInfoList.calls.push_back(emergencyInfo);
2535 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
2536 WaitFor(WAIT_TIME_SECOND);
2537 EXPECT_EQ(SUCCESS, ret);
2538 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_EMERGENCY_LIST));
2539 }
2540
2541 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetEmergencyCallList_V2_0100, Function | MediumTest | Level3)
2542 {
2543 if (!IsReady(SLOTID_2)) {
2544 return;
2545 }
2546 EmergencyInfoList emergencyInfoList;
2547 EmergencyCall emergencyInfo = {};
2548 emergencyInfo.index = 1;
2549 emergencyInfo.total = 1;
2550 emergencyInfo.eccNum = "120";
2551 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
2552 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
2553 emergencyInfo.mcc = "460";
2554 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
2555 emergencyInfoList.calls.push_back(emergencyInfo);
2556 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_2, GetSerialId(), emergencyInfoList);
2557 WaitFor(WAIT_TIME_SECOND);
2558 EXPECT_EQ(SUCCESS, ret);
2559 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_EMERGENCY_LIST));
2560 }
2561
2562 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallList_V1_0100, Function | MediumTest | Level3)
2563 {
2564 if (!IsReady(SLOTID_1)) {
2565 return;
2566 }
2567 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, GetSerialId());
2568 WaitFor(WAIT_TIME_SECOND);
2569 EXPECT_EQ(SUCCESS, ret);
2570 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_LIST));
2571 }
2572
2573 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallList_V1_0200, Function | MediumTest | Level3)
2574 {
2575 if (!IsReady(SLOTID_2)) {
2576 return;
2577 }
2578 int32_t ret = g_rilInterface->GetCallList(SLOTID_2, GetSerialId());
2579 WaitFor(WAIT_TIME_SECOND);
2580 EXPECT_EQ(SUCCESS, ret);
2581 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_LIST));
2582 }
2583
2584 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Dial_V1_0100, Function | MediumTest | Level3)
2585 {
2586 if (!IsReady(SLOTID_1)) {
2587 return;
2588 }
2589 DialInfo dialInfo = {};
2590 dialInfo.address = "10086";
2591 dialInfo.clir = 0;
2592 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
2593 WaitFor(WAIT_TIME_SECOND);
2594 EXPECT_EQ(SUCCESS, ret);
2595 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_DIAL));
2596 }
2597
2598 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Dial_V1_0200, Function | MediumTest | Level3)
2599 {
2600 if (!IsReady(SLOTID_2)) {
2601 return;
2602 }
2603 DialInfo dialInfo = {};
2604 dialInfo.address = "10086";
2605 dialInfo.clir = 0;
2606 int32_t ret = g_rilInterface->Dial(SLOTID_2, GetSerialId(), dialInfo);
2607 WaitFor(WAIT_TIME_SECOND);
2608 EXPECT_EQ(SUCCESS, ret);
2609 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_DIAL));
2610 }
2611
2612 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Reject_V1_0100, Function | MediumTest | Level3)
2613 {
2614 if (!IsReady(SLOTID_1)) {
2615 return;
2616 }
2617 int32_t ret = g_rilInterface->Reject(SLOTID_1, GetSerialId());
2618 WaitFor(WAIT_TIME_SECOND);
2619 EXPECT_EQ(SUCCESS, ret);
2620 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_REJECT));
2621 }
2622
2623 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Reject_V1_0200, Function | MediumTest | Level3)
2624 {
2625 if (!IsReady(SLOTID_2)) {
2626 return;
2627 }
2628 int32_t ret = g_rilInterface->Reject(SLOTID_2, GetSerialId());
2629 WaitFor(WAIT_TIME_SECOND);
2630 EXPECT_EQ(SUCCESS, ret);
2631 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_REJECT));
2632 }
2633
2634 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Hangup_V1_0100, Function | MediumTest | Level3)
2635 {
2636 if (!IsReady(SLOTID_1)) {
2637 return;
2638 }
2639 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), 0);
2640 WaitFor(WAIT_TIME_SECOND);
2641 EXPECT_EQ(SUCCESS, ret);
2642 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HANGUP));
2643 }
2644
2645 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Hangup_V1_0200, Function | MediumTest | Level3)
2646 {
2647 if (!IsReady(SLOTID_2)) {
2648 return;
2649 }
2650 int32_t ret = g_rilInterface->Hangup(SLOTID_2, GetSerialId(), 0);
2651 WaitFor(WAIT_TIME_SECOND);
2652 EXPECT_EQ(SUCCESS, ret);
2653 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HANGUP));
2654 }
2655
2656 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Answer_V1_0100, Function | MediumTest | Level3)
2657 {
2658 if (!IsReady(SLOTID_1)) {
2659 return;
2660 }
2661 int32_t ret = g_rilInterface->Answer(SLOTID_1, GetSerialId());
2662 WaitFor(WAIT_TIME_SECOND);
2663 EXPECT_EQ(SUCCESS, ret);
2664 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_ANSWER));
2665 }
2666
2667 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Answer_V1_0200, Function | MediumTest | Level3)
2668 {
2669 if (!IsReady(SLOTID_2)) {
2670 return;
2671 }
2672 int32_t ret = g_rilInterface->Answer(SLOTID_2, GetSerialId());
2673 WaitFor(WAIT_TIME_SECOND);
2674 EXPECT_EQ(SUCCESS, ret);
2675 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_ANSWER));
2676 }
2677
2678 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_HoldCall_V1_0100, Function | MediumTest | Level3)
2679 {
2680 if (!IsReady(SLOTID_1)) {
2681 return;
2682 }
2683 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, GetSerialId());
2684 WaitFor(WAIT_TIME_SECOND);
2685 EXPECT_EQ(SUCCESS, ret);
2686 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HOLD_CALL));
2687 }
2688
2689 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_HoldCall_V1_0200, Function | MediumTest | Level3)
2690 {
2691 if (!IsReady(SLOTID_2)) {
2692 return;
2693 }
2694 int32_t ret = g_rilInterface->HoldCall(SLOTID_2, GetSerialId());
2695 WaitFor(WAIT_TIME_SECOND);
2696 EXPECT_EQ(SUCCESS, ret);
2697 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HOLD_CALL));
2698 }
2699
2700 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnHoldCall_V1_0100, Function | MediumTest | Level3)
2701 {
2702 if (!IsReady(SLOTID_1)) {
2703 return;
2704 }
2705 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, GetSerialId());
2706 WaitFor(WAIT_TIME_SECOND);
2707 EXPECT_EQ(SUCCESS, ret);
2708 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_UNHOLD_CALL));
2709 }
2710
2711 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnHoldCall_V1_0200, Function | MediumTest | Level3)
2712 {
2713 if (!IsReady(SLOTID_2)) {
2714 return;
2715 }
2716 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_2, GetSerialId());
2717 WaitFor(WAIT_TIME_SECOND);
2718 EXPECT_EQ(SUCCESS, ret);
2719 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_UNHOLD_CALL));
2720 }
2721
2722 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SwitchCall_V1_0100, Function | MediumTest | Level3)
2723 {
2724 if (!IsReady(SLOTID_1)) {
2725 return;
2726 }
2727 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, GetSerialId());
2728 WaitFor(WAIT_TIME_SECOND);
2729 EXPECT_EQ(SUCCESS, ret);
2730 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SWITCH_CALL));
2731 }
2732
2733 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SwitchCall_V1_0200, Function | MediumTest | Level3)
2734 {
2735 if (!IsReady(SLOTID_2)) {
2736 return;
2737 }
2738 int32_t ret = g_rilInterface->SwitchCall(SLOTID_2, GetSerialId());
2739 WaitFor(WAIT_TIME_SECOND);
2740 EXPECT_EQ(SUCCESS, ret);
2741 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SWITCH_CALL));
2742 }
2743
2744 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CombineConference_V1_0100, Function | MediumTest | Level3)
2745 {
2746 if (!IsReady(SLOTID_1)) {
2747 return;
2748 }
2749 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, GetSerialId(), 0);
2750 WaitFor(WAIT_TIME_SECOND);
2751 EXPECT_EQ(SUCCESS, ret);
2752 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_COMBINE_CONFERENCE));
2753 }
2754
2755 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CombineConference_V1_0200, Function | MediumTest | Level3)
2756 {
2757 if (!IsReady(SLOTID_2)) {
2758 return;
2759 }
2760 int32_t ret = g_rilInterface->CombineConference(SLOTID_2, GetSerialId(), 0);
2761 WaitFor(WAIT_TIME_SECOND);
2762 EXPECT_EQ(SUCCESS, ret);
2763 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_COMBINE_CONFERENCE));
2764 }
2765
2766 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SeparateConference_V1_0100, Function | MediumTest | Level3)
2767 {
2768 if (!IsReady(SLOTID_1)) {
2769 return;
2770 }
2771 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), 1, 0);
2772 WaitFor(WAIT_TIME_SECOND);
2773 EXPECT_EQ(SUCCESS, ret);
2774 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEPARATE_CONFERENCE));
2775 }
2776
2777 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SeparateConference_V1_0200, Function | MediumTest | Level3)
2778 {
2779 if (!IsReady(SLOTID_2)) {
2780 return;
2781 }
2782 int32_t ret = g_rilInterface->SeparateConference(SLOTID_2, GetSerialId(), 1, 0);
2783 WaitFor(WAIT_TIME_SECOND);
2784 EXPECT_EQ(SUCCESS, ret);
2785 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEPARATE_CONFERENCE));
2786 }
2787
2788 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallWaiting_V1_0100, Function | MediumTest | Level3)
2789 {
2790 if (!IsReady(SLOTID_1)) {
2791 return;
2792 }
2793 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, GetSerialId());
2794 WaitFor(WAIT_TIME_SECOND);
2795 EXPECT_EQ(SUCCESS, ret);
2796 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_WAITING));
2797 }
2798
2799 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallWaiting_V1_0200, Function | MediumTest | Level3)
2800 {
2801 if (!IsReady(SLOTID_2)) {
2802 return;
2803 }
2804 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_2, GetSerialId());
2805 WaitFor(WAIT_TIME_SECOND);
2806 EXPECT_EQ(SUCCESS, ret);
2807 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_WAITING));
2808 }
2809
2810 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallWaiting_V1_0100, Function | MediumTest | Level3)
2811 {
2812 if (!IsReady(SLOTID_1)) {
2813 return;
2814 }
2815 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), 0);
2816 WaitFor(WAIT_TIME_SECOND);
2817 EXPECT_EQ(SUCCESS, ret);
2818 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_WAITING));
2819 }
2820
2821 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallWaiting_V1_0200, Function | MediumTest | Level3)
2822 {
2823 if (!IsReady(SLOTID_2)) {
2824 return;
2825 }
2826 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_2, GetSerialId(), 0);
2827 WaitFor(WAIT_TIME_SECOND);
2828 EXPECT_EQ(SUCCESS, ret);
2829 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_WAITING));
2830 }
2831
2832 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallTransferInfo_V1_0100, Function | MediumTest | Level3)
2833 {
2834 if (!IsReady(SLOTID_1)) {
2835 return;
2836 }
2837 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 1);
2838 WaitFor(WAIT_TIME_SECOND);
2839 EXPECT_EQ(SUCCESS, ret);
2840 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO));
2841 }
2842
2843 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallTransferInfo_V1_0200, Function | MediumTest | Level3)
2844 {
2845 if (!IsReady(SLOTID_2)) {
2846 return;
2847 }
2848 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_2, GetSerialId(), 1);
2849 WaitFor(WAIT_TIME_SECOND);
2850 EXPECT_EQ(SUCCESS, ret);
2851 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO));
2852 }
2853
2854 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallTransferInfo_V1_0100, Function | MediumTest | Level3)
2855 {
2856 if (!IsReady(SLOTID_1)) {
2857 return;
2858 }
2859 CallForwardSetInfo callForwardSetInfo = {};
2860 callForwardSetInfo.reason = 1;
2861 callForwardSetInfo.mode = 1;
2862 callForwardSetInfo.classx = 1;
2863 callForwardSetInfo.number = "10086";
2864 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2865 WaitFor(WAIT_TIME_SECOND);
2866 EXPECT_EQ(SUCCESS, ret);
2867 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO));
2868 }
2869
2870 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallTransferInfo_V1_0200, Function | MediumTest | Level3)
2871 {
2872 if (!IsReady(SLOTID_2)) {
2873 return;
2874 }
2875 CallForwardSetInfo callForwardSetInfo = {};
2876 callForwardSetInfo.reason = 1;
2877 callForwardSetInfo.mode = 1;
2878 callForwardSetInfo.classx = 1;
2879 callForwardSetInfo.number = "10086";
2880 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_2, GetSerialId(), callForwardSetInfo);
2881 WaitFor(WAIT_TIME_SECOND);
2882 EXPECT_EQ(SUCCESS, ret);
2883 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO));
2884 }
2885
2886 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallRestriction_V1_0100, Function | MediumTest | Level3)
2887 {
2888 if (!IsReady(SLOTID_1)) {
2889 return;
2890 }
2891 std::string fac = "AO";
2892 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, GetSerialId(), fac);
2893 WaitFor(WAIT_TIME_SECOND);
2894 EXPECT_EQ(SUCCESS, ret);
2895 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_RESTRICTION));
2896 }
2897
2898 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallRestriction_V1_0200, Function | MediumTest | Level3)
2899 {
2900 if (!IsReady(SLOTID_2)) {
2901 return;
2902 }
2903 std::string fac = "AO";
2904 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_2, GetSerialId(), fac);
2905 WaitFor(WAIT_TIME_SECOND);
2906 EXPECT_EQ(SUCCESS, ret);
2907 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_RESTRICTION));
2908 }
2909
2910 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallRestriction_V1_0100, Function | MediumTest | Level3)
2911 {
2912 if (!IsReady(SLOTID_1)) {
2913 return;
2914 }
2915 CallRestrictionInfo callRestrictionInfo = {};
2916 callRestrictionInfo.fac = "AO";
2917 callRestrictionInfo.mode = 1;
2918 callRestrictionInfo.password = "123456";
2919 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
2920 WaitFor(WAIT_TIME_SECOND);
2921 EXPECT_EQ(SUCCESS, ret);
2922 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_RESTRICTION));
2923 }
2924
2925 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallRestriction_V1_0200, Function | MediumTest | Level3)
2926 {
2927 if (!IsReady(SLOTID_2)) {
2928 return;
2929 }
2930 CallRestrictionInfo callRestrictionInfo = {};
2931 callRestrictionInfo.fac = "AO";
2932 callRestrictionInfo.mode = 1;
2933 callRestrictionInfo.password = "123456";
2934 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_2, GetSerialId(), callRestrictionInfo);
2935 WaitFor(WAIT_TIME_SECOND);
2936 EXPECT_EQ(SUCCESS, ret);
2937 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_RESTRICTION));
2938 }
2939
2940 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClip_V1_0100, Function | MediumTest | Level3)
2941 {
2942 if (!IsReady(SLOTID_1)) {
2943 return;
2944 }
2945 int32_t ret = g_rilInterface->GetClip(SLOTID_1, GetSerialId());
2946 WaitFor(WAIT_TIME_SECOND);
2947 EXPECT_EQ(SUCCESS, ret);
2948 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIP));
2949 }
2950
2951 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClip_V1_0200, Function | MediumTest | Level3)
2952 {
2953 if (!IsReady(SLOTID_2)) {
2954 return;
2955 }
2956 int32_t ret = g_rilInterface->GetClip(SLOTID_2, GetSerialId());
2957 WaitFor(WAIT_TIME_SECOND);
2958 EXPECT_EQ(SUCCESS, ret);
2959 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIP));
2960 }
2961
2962 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClip_V1_0100, Function | MediumTest | Level3)
2963 {
2964 if (!IsReady(SLOTID_1)) {
2965 return;
2966 }
2967 int32_t ret = g_rilInterface->SetClip(SLOTID_1, GetSerialId(), 1);
2968 WaitFor(WAIT_TIME_SECOND);
2969 EXPECT_EQ(SUCCESS, ret);
2970 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIP));
2971 }
2972
2973 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClip_V1_0200, Function | MediumTest | Level3)
2974 {
2975 if (!IsReady(SLOTID_2)) {
2976 return;
2977 }
2978 int32_t ret = g_rilInterface->SetClip(SLOTID_2, GetSerialId(), 1);
2979 WaitFor(WAIT_TIME_SECOND);
2980 EXPECT_EQ(SUCCESS, ret);
2981 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIP));
2982 }
2983
2984 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClir_V1_0100, Function | MediumTest | Level3)
2985 {
2986 if (!IsReady(SLOTID_1)) {
2987 return;
2988 }
2989 int32_t ret = g_rilInterface->GetClir(SLOTID_1, GetSerialId());
2990 WaitFor(WAIT_TIME_SECOND);
2991 EXPECT_EQ(SUCCESS, ret);
2992 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIR));
2993 }
2994
2995 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClir_V1_0200, Function | MediumTest | Level3)
2996 {
2997 if (!IsReady(SLOTID_2)) {
2998 return;
2999 }
3000 int32_t ret = g_rilInterface->GetClir(SLOTID_2, GetSerialId());
3001 WaitFor(WAIT_TIME_SECOND);
3002 EXPECT_EQ(SUCCESS, ret);
3003 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIR));
3004 }
3005
3006 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClir_V1_0100, Function | MediumTest | Level3)
3007 {
3008 if (!IsReady(SLOTID_1)) {
3009 return;
3010 }
3011 int32_t ret = g_rilInterface->SetClir(SLOTID_1, GetSerialId(), 1);
3012 WaitFor(WAIT_TIME_SECOND);
3013 EXPECT_EQ(SUCCESS, ret);
3014 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIR));
3015 }
3016
3017 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClir_V1_0200, Function | MediumTest | Level3)
3018 {
3019 if (!IsReady(SLOTID_2)) {
3020 return;
3021 }
3022 int32_t ret = g_rilInterface->SetClir(SLOTID_2, GetSerialId(), 1);
3023 WaitFor(WAIT_TIME_SECOND);
3024 EXPECT_EQ(SUCCESS, ret);
3025 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIR));
3026 }
3027
3028 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallPreferenceMode_V1_0100, Function | MediumTest | Level3)
3029 {
3030 if (!IsReady(SLOTID_1)) {
3031 return;
3032 }
3033 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 1);
3034 WaitFor(WAIT_TIME_SECOND);
3035 EXPECT_EQ(SUCCESS, ret);
3036 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_PREFERENCE));
3037 }
3038
3039 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallPreferenceMode_V1_0200, Function | MediumTest | Level3)
3040 {
3041 if (!IsReady(SLOTID_2)) {
3042 return;
3043 }
3044 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_2, GetSerialId(), 1);
3045 WaitFor(WAIT_TIME_SECOND);
3046 EXPECT_EQ(SUCCESS, ret);
3047 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_PREFERENCE));
3048 }
3049
3050 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallPreferenceMode_V1_0100, Function | MediumTest | Level3)
3051 {
3052 if (!IsReady(SLOTID_1)) {
3053 return;
3054 }
3055 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, GetSerialId());
3056 WaitFor(WAIT_TIME_SECOND);
3057 EXPECT_EQ(SUCCESS, ret);
3058 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_PREFERENCE));
3059 }
3060
3061 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallPreferenceMode_V1_0200, Function | MediumTest | Level3)
3062 {
3063 if (!IsReady(SLOTID_2)) {
3064 return;
3065 }
3066 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_2, GetSerialId());
3067 WaitFor(WAIT_TIME_SECOND);
3068 EXPECT_EQ(SUCCESS, ret);
3069 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_PREFERENCE));
3070 }
3071
3072 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetUssd_V1_0100, Function | MediumTest | Level3)
3073 {
3074 if (!IsReady(SLOTID_1)) {
3075 return;
3076 }
3077 int32_t ret = g_rilInterface->SetUssd(SLOTID_1, GetSerialId(), "12345678");
3078 WaitFor(WAIT_TIME_SECOND);
3079 EXPECT_EQ(SUCCESS, ret);
3080 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_USSD));
3081 }
3082
3083 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetUssd_V1_0200, Function | MediumTest | Level3)
3084 {
3085 if (!IsReady(SLOTID_2)) {
3086 return;
3087 }
3088 int32_t ret = g_rilInterface->SetUssd(SLOTID_2, GetSerialId(), "12345678");
3089 WaitFor(WAIT_TIME_SECOND);
3090 EXPECT_EQ(SUCCESS, ret);
3091 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_USSD));
3092 }
3093
3094 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetUssd_V1_0100, Function | MediumTest | Level3)
3095 {
3096 if (!IsReady(SLOTID_1)) {
3097 return;
3098 }
3099 int32_t ret = g_rilInterface->GetUssd(SLOTID_1, GetSerialId());
3100 WaitFor(WAIT_TIME_SECOND);
3101 EXPECT_EQ(SUCCESS, ret);
3102 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_USSD));
3103 }
3104
3105 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetUssd_V1_0200, Function | MediumTest | Level3)
3106 {
3107 if (!IsReady(SLOTID_2)) {
3108 return;
3109 }
3110 int32_t ret = g_rilInterface->GetUssd(SLOTID_2, GetSerialId());
3111 WaitFor(WAIT_TIME_SECOND);
3112 EXPECT_EQ(SUCCESS, ret);
3113 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_USSD));
3114 }
3115
3116 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetMute_V1_0100, Function | MediumTest | Level3)
3117 {
3118 if (!IsReady(SLOTID_1)) {
3119 return;
3120 }
3121 int32_t ret = g_rilInterface->SetMute(SLOTID_1, GetSerialId(), 1);
3122 WaitFor(WAIT_TIME_SECOND);
3123 EXPECT_EQ(SUCCESS, ret);
3124 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_MUTE));
3125 }
3126
3127 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetMute_V1_0200, Function | MediumTest | Level3)
3128 {
3129 if (!IsReady(SLOTID_2)) {
3130 return;
3131 }
3132 int32_t ret = g_rilInterface->SetMute(SLOTID_2, GetSerialId(), 1);
3133 WaitFor(WAIT_TIME_SECOND);
3134 EXPECT_EQ(SUCCESS, ret);
3135 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_MUTE));
3136 }
3137
3138 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMute_V1_0100, Function | MediumTest | Level3)
3139 {
3140 if (!IsReady(SLOTID_1)) {
3141 return;
3142 }
3143 int32_t ret = g_rilInterface->GetMute(SLOTID_1, GetSerialId());
3144 WaitFor(WAIT_TIME_SECOND);
3145 EXPECT_EQ(SUCCESS, ret);
3146 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_MUTE));
3147 }
3148
3149 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMute_V1_0200, Function | MediumTest | Level3)
3150 {
3151 if (!IsReady(SLOTID_2)) {
3152 return;
3153 }
3154 int32_t ret = g_rilInterface->GetMute(SLOTID_2, GetSerialId());
3155 WaitFor(WAIT_TIME_SECOND);
3156 EXPECT_EQ(SUCCESS, ret);
3157 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_MUTE));
3158 }
3159
3160 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallFailReason_V1_0100, Function | MediumTest | Level3)
3161 {
3162 if (!IsReady(SLOTID_1)) {
3163 return;
3164 }
3165 int32_t ret = g_rilInterface->GetCallFailReason(SLOTID_1, GetSerialId());
3166 WaitFor(WAIT_TIME_SECOND);
3167 EXPECT_EQ(SUCCESS, ret);
3168 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_FAIL_REASON));
3169 }
3170
3171 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallFailReason_V1_0200, Function | MediumTest | Level3)
3172 {
3173 if (!IsReady(SLOTID_2)) {
3174 return;
3175 }
3176 int32_t ret = g_rilInterface->GetCallFailReason(SLOTID_2, GetSerialId());
3177 WaitFor(WAIT_TIME_SECOND);
3178 EXPECT_EQ(SUCCESS, ret);
3179 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_FAIL_REASON));
3180 }
3181
3182 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CallSupplement_V1_0100, Function | MediumTest | Level3)
3183 {
3184 if (!IsReady(SLOTID_1)) {
3185 return;
3186 }
3187 int32_t ret = g_rilInterface->CallSupplement(SLOTID_1, GetSerialId(), 1);
3188 WaitFor(WAIT_TIME_SECOND);
3189 EXPECT_EQ(SUCCESS, ret);
3190 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CALL_SUPPLEMENT));
3191 }
3192
3193 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CallSupplement_V1_0200, Function | MediumTest | Level3)
3194 {
3195 if (!IsReady(SLOTID_2)) {
3196 return;
3197 }
3198 int32_t ret = g_rilInterface->CallSupplement(SLOTID_2, GetSerialId(), 1);
3199 WaitFor(WAIT_TIME_SECOND);
3200 EXPECT_EQ(SUCCESS, ret);
3201 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CALL_SUPPLEMENT));
3202 }
3203
3204 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDtmf_V1_0100, Function | MediumTest | Level3)
3205 {
3206 if (!IsReady(SLOTID_1)) {
3207 return;
3208 }
3209 DtmfInfo dtmfInfo = {};
3210 dtmfInfo.callId = 0;
3211 dtmfInfo.dtmfKey = "#";
3212 dtmfInfo.onLength = 300;
3213 dtmfInfo.offLength = 0;
3214 dtmfInfo.stringLength = 1;
3215 int32_t ret = g_rilInterface->SendDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3216 WaitFor(WAIT_TIME_SECOND);
3217 EXPECT_EQ(SUCCESS, ret);
3218 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEND_DTMF));
3219 }
3220
3221 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDtmf_V1_0200, Function | MediumTest | Level3)
3222 {
3223 if (!IsReady(SLOTID_2)) {
3224 return;
3225 }
3226 DtmfInfo dtmfInfo = {};
3227 dtmfInfo.callId = 0;
3228 dtmfInfo.dtmfKey = "#";
3229 dtmfInfo.onLength = 1;
3230 dtmfInfo.offLength = 0;
3231 dtmfInfo.stringLength = 1;
3232 int32_t ret = g_rilInterface->SendDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3233 WaitFor(WAIT_TIME_SECOND);
3234 EXPECT_EQ(SUCCESS, ret);
3235 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEND_DTMF));
3236 }
3237
3238 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StartDtmf_V1_0100, Function | MediumTest | Level3)
3239 {
3240 if (!IsReady(SLOTID_1)) {
3241 return;
3242 }
3243 DtmfInfo dtmfInfo = {};
3244 dtmfInfo.callId = 0;
3245 dtmfInfo.dtmfKey = "#";
3246 int32_t ret = g_rilInterface->StartDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3247 WaitFor(WAIT_TIME_SECOND);
3248 EXPECT_EQ(SUCCESS, ret);
3249 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_START_DTMF));
3250 }
3251
3252 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StartDtmf_V1_0200, Function | MediumTest | Level3)
3253 {
3254 if (!IsReady(SLOTID_2)) {
3255 return;
3256 }
3257 DtmfInfo dtmfInfo = {};
3258 dtmfInfo.callId = 0;
3259 dtmfInfo.dtmfKey = "#";
3260 int32_t ret = g_rilInterface->StartDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3261 WaitFor(WAIT_TIME_SECOND);
3262 EXPECT_EQ(SUCCESS, ret);
3263 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_START_DTMF));
3264 }
3265
3266 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StopDtmf_V1_0100, Function | MediumTest | Level3)
3267 {
3268 if (!IsReady(SLOTID_1)) {
3269 return;
3270 }
3271 DtmfInfo dtmfInfo = {};
3272 dtmfInfo.callId = 0;
3273 dtmfInfo.dtmfKey = "#";
3274 int32_t ret = g_rilInterface->StopDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3275 WaitFor(WAIT_TIME_SECOND);
3276 EXPECT_EQ(SUCCESS, ret);
3277 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_STOP_DTMF));
3278 }
3279
3280 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StopDtmf_V1_0200, Function | MediumTest | Level3)
3281 {
3282 if (!IsReady(SLOTID_2)) {
3283 return;
3284 }
3285 DtmfInfo dtmfInfo = {};
3286 dtmfInfo.callId = 0;
3287 dtmfInfo.dtmfKey = "#";
3288 int32_t ret = g_rilInterface->StopDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3289 WaitFor(WAIT_TIME_SECOND);
3290 EXPECT_EQ(SUCCESS, ret);
3291 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_STOP_DTMF));
3292 }
3293
3294 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetBarringPassword_V1_0100, Function | MediumTest | Level3)
3295 {
3296 if (!IsReady(SLOTID_1)) {
3297 return;
3298 }
3299 SetBarringInfo setBarringInfo = {};
3300 setBarringInfo.fac = "AB";
3301 setBarringInfo.oldPassword = "1234";
3302 setBarringInfo.newPassword = "2345";
3303 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
3304 WaitFor(WAIT_TIME_SECOND);
3305 EXPECT_EQ(SUCCESS, ret);
3306 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_BARRING_PASSWORD));
3307 }
3308
3309 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetBarringPassword_V1_0200, Function | MediumTest | Level3)
3310 {
3311 if (!IsReady(SLOTID_2)) {
3312 return;
3313 }
3314 SetBarringInfo setBarringInfo = {};
3315 setBarringInfo.fac = "AB";
3316 setBarringInfo.oldPassword = "1234";
3317 setBarringInfo.newPassword = "2345";
3318 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_2, GetSerialId(), setBarringInfo);
3319 WaitFor(WAIT_TIME_SECOND);
3320 EXPECT_EQ(SUCCESS, ret);
3321 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_BARRING_PASSWORD));
3322 }
3323
3324 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CloseUnFinishedUssd_V1_0100, Function | MediumTest | Level3)
3325 {
3326 if (!IsReady(SLOTID_1)) {
3327 return;
3328 }
3329 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, GetSerialId());
3330 WaitFor(WAIT_TIME_SECOND);
3331 EXPECT_EQ(SUCCESS, ret);
3332 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD));
3333 }
3334
3335 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CloseUnFinishedUssd_V1_0200, Function | MediumTest | Level3)
3336 {
3337 if (!IsReady(SLOTID_2)) {
3338 return;
3339 }
3340 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_2, GetSerialId());
3341 WaitFor(WAIT_TIME_SECOND);
3342 EXPECT_EQ(SUCCESS, ret);
3343 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD));
3344 }
3345
3346 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetVonrSwitch_V1_0100, Function | MediumTest | Level3)
3347 {
3348 if (!IsReady(SLOTID_1)) {
3349 return;
3350 }
3351 int32_t ret = g_rilInterface->SetVonrSwitch(SLOTID_1, GetSerialId(), 1);
3352 WaitFor(WAIT_TIME_SECOND);
3353 EXPECT_EQ(SUCCESS, ret);
3354 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SET_VONR_SWITCH));
3355 }
3356
3357 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetVonrSwitch_V1_0200, Function | MediumTest | Level3)
3358 {
3359 if (!IsReady(SLOTID_2)) {
3360 return;
3361 }
3362 int32_t ret = g_rilInterface->SetVonrSwitch(SLOTID_2, GetSerialId(), 1);
3363 WaitFor(WAIT_TIME_SECOND);
3364 EXPECT_EQ(SUCCESS, ret);
3365 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SET_VONR_SWITCH));
3366 }
3367
3368 // Network
3369 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSignalStrength_V1_0100, Function | MediumTest | Level3)
3370 {
3371 if (!IsReady(SLOTID_1)) {
3372 return;
3373 }
3374 int32_t ret = g_rilInterface->GetSignalStrength(SLOTID_1, GetSerialId());
3375 WaitFor(WAIT_TIME_SECOND);
3376 EXPECT_EQ(SUCCESS, ret);
3377 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH));
3378 }
3379
3380 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSignalStrength_V1_0200, Function | MediumTest | Level3)
3381 {
3382 if (!IsReady(SLOTID_2)) {
3383 return;
3384 }
3385 int32_t ret = g_rilInterface->GetSignalStrength(SLOTID_2, GetSerialId());
3386 WaitFor(WAIT_TIME_SECOND);
3387 EXPECT_EQ(SUCCESS, ret);
3388 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH));
3389 }
3390
3391 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCsRegStatus_V1_0100, Function | MediumTest | Level3)
3392 {
3393 if (!IsReady(SLOTID_1)) {
3394 return;
3395 }
3396 int32_t ret = g_rilInterface->GetCsRegStatus(SLOTID_1, GetSerialId());
3397 WaitFor(WAIT_TIME_SECOND);
3398 EXPECT_EQ(SUCCESS, ret);
3399 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CS_REG_STATUS));
3400 }
3401
3402 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCsRegStatus_V1_0200, Function | MediumTest | Level3)
3403 {
3404 if (!IsReady(SLOTID_2)) {
3405 return;
3406 }
3407 int32_t ret = g_rilInterface->GetCsRegStatus(SLOTID_2, GetSerialId());
3408 WaitFor(WAIT_TIME_SECOND);
3409 EXPECT_EQ(SUCCESS, ret);
3410 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CS_REG_STATUS));
3411 }
3412
3413 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPsRegStatus_V1_0100, Function | MediumTest | Level3)
3414 {
3415 if (!IsReady(SLOTID_1)) {
3416 return;
3417 }
3418 int32_t ret = g_rilInterface->GetPsRegStatus(SLOTID_1, GetSerialId());
3419 WaitFor(WAIT_TIME_SECOND);
3420 EXPECT_EQ(SUCCESS, ret);
3421 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PS_REG_STATUS));
3422 }
3423
3424 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPsRegStatus_V1_0200, Function | MediumTest | Level3)
3425 {
3426 if (!IsReady(SLOTID_2)) {
3427 return;
3428 }
3429 int32_t ret = g_rilInterface->GetPsRegStatus(SLOTID_2, GetSerialId());
3430 WaitFor(WAIT_TIME_SECOND);
3431 EXPECT_EQ(SUCCESS, ret);
3432 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PS_REG_STATUS));
3433 }
3434
3435 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetOperatorInfo_V1_0100, Function | MediumTest | Level3)
3436 {
3437 if (!IsReady(SLOTID_1)) {
3438 return;
3439 }
3440 int32_t ret = g_rilInterface->GetOperatorInfo(SLOTID_1, GetSerialId());
3441 WaitFor(WAIT_TIME_SECOND);
3442 EXPECT_EQ(SUCCESS, ret);
3443 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_OPERATOR_INFO));
3444 }
3445
3446 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetOperatorInfo_V1_0200, Function | MediumTest | Level3)
3447 {
3448 if (!IsReady(SLOTID_2)) {
3449 return;
3450 }
3451 int32_t ret = g_rilInterface->GetOperatorInfo(SLOTID_2, GetSerialId());
3452 WaitFor(WAIT_TIME_SECOND);
3453 EXPECT_EQ(SUCCESS, ret);
3454 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_OPERATOR_INFO));
3455 }
3456
3457 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSearchInformation_V1_0100, Function | MediumTest | Level3)
3458 {
3459 if (!IsReady(SLOTID_1)) {
3460 return;
3461 }
3462 int32_t ret = g_rilInterface->GetNetworkSearchInformation(SLOTID_1, GetSerialId());
3463 WaitFor(WAIT_TIME_SECOND);
3464 EXPECT_EQ(SUCCESS, ret);
3465 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION));
3466 }
3467
3468 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSearchInformation_V1_0200, Function | MediumTest | Level3)
3469 {
3470 if (!IsReady(SLOTID_2)) {
3471 return;
3472 }
3473 int32_t ret = g_rilInterface->GetNetworkSearchInformation(SLOTID_2, GetSerialId());
3474 WaitFor(WAIT_TIME_SECOND);
3475 EXPECT_EQ(SUCCESS, ret);
3476 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION));
3477 }
3478
3479 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSelectionMode_V1_0100, Function | MediumTest | Level3)
3480 {
3481 if (!IsReady(SLOTID_1)) {
3482 return;
3483 }
3484 int32_t ret = g_rilInterface->GetNetworkSelectionMode(SLOTID_1, GetSerialId());
3485 WaitFor(WAIT_TIME_SECOND);
3486 EXPECT_EQ(SUCCESS, ret);
3487 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE));
3488 }
3489
3490 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSelectionMode_V1_0200, Function | MediumTest | Level3)
3491 {
3492 if (!IsReady(SLOTID_2)) {
3493 return;
3494 }
3495 int32_t ret = g_rilInterface->GetNetworkSelectionMode(SLOTID_2, GetSerialId());
3496 WaitFor(WAIT_TIME_SECOND);
3497 EXPECT_EQ(SUCCESS, ret);
3498 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE));
3499 }
3500
3501 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNetworkSelectionMode_V1_0100, Function | MediumTest | Level3)
3502 {
3503 if (!IsReady(SLOTID_1)) {
3504 return;
3505 }
3506 SetNetworkModeInfo setNetworkModeInfo;
3507 setNetworkModeInfo.selectMode = static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO);
3508 setNetworkModeInfo.oper = "46000";
3509 int32_t ret = g_rilInterface->SetNetworkSelectionMode(SLOTID_1, GetSerialId(), setNetworkModeInfo);
3510 WaitFor(WAIT_TIME_SECOND);
3511 EXPECT_EQ(SUCCESS, ret);
3512 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE));
3513 }
3514
3515 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNetworkSelectionMode_V1_0200, Function | MediumTest | Level3)
3516 {
3517 if (!IsReady(SLOTID_2)) {
3518 return;
3519 }
3520 SetNetworkModeInfo setNetworkModeInfo;
3521 setNetworkModeInfo.selectMode = static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO);
3522 setNetworkModeInfo.oper = "46000";
3523 int32_t ret = g_rilInterface->SetNetworkSelectionMode(SLOTID_2, GetSerialId(), setNetworkModeInfo);
3524 WaitFor(WAIT_TIME_SECOND);
3525 EXPECT_EQ(SUCCESS, ret);
3526 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE));
3527 }
3528
3529 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetPreferredNetwork_V1_0100, Function | MediumTest | Level3)
3530 {
3531 if (!IsReady(SLOTID_1)) {
3532 return;
3533 }
3534 int32_t ret = g_rilInterface->SetPreferredNetwork(
3535 SLOTID_1, GetSerialId(), static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE));
3536 WaitFor(WAIT_TIME_SECOND);
3537 EXPECT_EQ(SUCCESS, ret);
3538 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK));
3539 }
3540
3541 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetPreferredNetwork_V1_0200, Function | MediumTest | Level3)
3542 {
3543 if (!IsReady(SLOTID_2)) {
3544 return;
3545 }
3546 int32_t ret = g_rilInterface->SetPreferredNetwork(
3547 SLOTID_2, GetSerialId(), static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE));
3548 WaitFor(WAIT_TIME_SECOND);
3549 EXPECT_EQ(SUCCESS, ret);
3550 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK));
3551 }
3552
3553 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPreferredNetwork_V1_0100, Function | MediumTest | Level3)
3554 {
3555 if (!IsReady(SLOTID_1)) {
3556 return;
3557 }
3558 int32_t ret = g_rilInterface->GetPreferredNetwork(SLOTID_1, GetSerialId());
3559 WaitFor(WAIT_TIME_SECOND);
3560 EXPECT_EQ(SUCCESS, ret);
3561 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK));
3562 }
3563
3564 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPreferredNetwork_V1_0200, Function | MediumTest | Level3)
3565 {
3566 if (!IsReady(SLOTID_2)) {
3567 return;
3568 }
3569 int32_t ret = g_rilInterface->GetPreferredNetwork(SLOTID_2, GetSerialId());
3570 WaitFor(WAIT_TIME_SECOND);
3571 EXPECT_EQ(SUCCESS, ret);
3572 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK));
3573 }
3574
3575 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCellInfoList_V1_0100, Function | MediumTest | Level3)
3576 {
3577 if (!IsReady(SLOTID_1)) {
3578 return;
3579 }
3580 int32_t ret = g_rilInterface->GetNeighboringCellInfoList(SLOTID_1, GetSerialId());
3581 WaitFor(WAIT_TIME_SECOND);
3582 EXPECT_EQ(SUCCESS, ret);
3583 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST));
3584 }
3585
3586 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCellInfoList_V1_0200, Function | MediumTest | Level3)
3587 {
3588 if (!IsReady(SLOTID_2)) {
3589 return;
3590 }
3591 int32_t ret = g_rilInterface->GetNeighboringCellInfoList(SLOTID_2, GetSerialId());
3592 WaitFor(WAIT_TIME_SECOND);
3593 EXPECT_EQ(SUCCESS, ret);
3594 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST));
3595 }
3596
3597 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCurrentCellInfo_V1_0100, Function | MediumTest | Level3)
3598 {
3599 if (!IsReady(SLOTID_1)) {
3600 return;
3601 }
3602 int32_t ret = g_rilInterface->GetCurrentCellInfo(SLOTID_1, GetSerialId());
3603 WaitFor(WAIT_TIME_SECOND);
3604 EXPECT_EQ(SUCCESS, ret);
3605 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO));
3606 }
3607
3608 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCurrentCellInfo_V1_0200, Function | MediumTest | Level3)
3609 {
3610 if (!IsReady(SLOTID_2)) {
3611 return;
3612 }
3613 int32_t ret = g_rilInterface->GetCurrentCellInfo(SLOTID_2, GetSerialId());
3614 WaitFor(WAIT_TIME_SECOND);
3615 EXPECT_EQ(SUCCESS, ret);
3616 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO));
3617 }
3618
3619 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPhysicalChannelConfig_V1_0100, Function | MediumTest | Level3)
3620 {
3621 if (!IsReady(SLOTID_1)) {
3622 return;
3623 }
3624 int32_t ret = g_rilInterface->GetPhysicalChannelConfig(SLOTID_1, GetSerialId());
3625 WaitFor(WAIT_TIME_SECOND);
3626 EXPECT_EQ(SUCCESS, ret);
3627 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG));
3628 }
3629
3630 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPhysicalChannelConfig_V1_0200, Function | MediumTest | Level3)
3631 {
3632 if (!IsReady(SLOTID_2)) {
3633 return;
3634 }
3635 int32_t ret = g_rilInterface->GetPhysicalChannelConfig(SLOTID_2, GetSerialId());
3636 WaitFor(WAIT_TIME_SECOND);
3637 EXPECT_EQ(SUCCESS, ret);
3638 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG));
3639 }
3640
3641 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLocateUpdates_V1_0100, Function | MediumTest | Level3)
3642 {
3643 if (!IsReady(SLOTID_1)) {
3644 return;
3645 }
3646 int32_t ret =
3647 g_rilInterface->SetLocateUpdates(SLOTID_1, GetSerialId(), RilRegNotifyMode::REG_NOTIFY_STAT_LAC_CELLID);
3648 WaitFor(WAIT_TIME_SECOND);
3649 EXPECT_EQ(SUCCESS, ret);
3650 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES));
3651 }
3652
3653 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLocateUpdates_V1_0200, Function | MediumTest | Level3)
3654 {
3655 if (!IsReady(SLOTID_2)) {
3656 return;
3657 }
3658 int32_t ret =
3659 g_rilInterface->SetLocateUpdates(SLOTID_2, GetSerialId(), RilRegNotifyMode::REG_NOTIFY_STAT_LAC_CELLID);
3660 WaitFor(WAIT_TIME_SECOND);
3661 EXPECT_EQ(SUCCESS, ret);
3662 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES));
3663 }
3664
3665 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNotificationFilter_V1_0100, Function | MediumTest | Level3)
3666 {
3667 if (!IsReady(SLOTID_1)) {
3668 return;
3669 }
3670 int32_t ret = g_rilInterface->SetNotificationFilter(
3671 SLOTID_1, GetSerialId(), static_cast<int32_t>(NotificationFilter::NOTIFICATION_FILTER_ALL));
3672 WaitFor(WAIT_TIME_SECOND);
3673 EXPECT_EQ(SUCCESS, ret);
3674 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER));
3675 }
3676
3677 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNotificationFilter_V1_0200, Function | MediumTest | Level3)
3678 {
3679 if (!IsReady(SLOTID_2)) {
3680 return;
3681 }
3682 int32_t ret = g_rilInterface->SetNotificationFilter(
3683 SLOTID_2, GetSerialId(), static_cast<int32_t>(NotificationFilter::NOTIFICATION_FILTER_ALL));
3684 WaitFor(WAIT_TIME_SECOND);
3685 EXPECT_EQ(SUCCESS, ret);
3686 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER));
3687 }
3688
3689 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDeviceState_V1_0100, Function | MediumTest | Level3)
3690 {
3691 if (!IsReady(SLOTID_1)) {
3692 return;
3693 }
3694 int32_t ret = g_rilInterface->SetDeviceState(
3695 SLOTID_1, GetSerialId(), static_cast<int32_t>(DeviceStateType::LOW_DATA_STATE), 0);
3696 WaitFor(WAIT_TIME_SECOND);
3697 EXPECT_EQ(SUCCESS, ret);
3698 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_DEVICE_STATE));
3699 }
3700
3701 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDeviceState_V1_0200, Function | MediumTest | Level3)
3702 {
3703 if (!IsReady(SLOTID_2)) {
3704 return;
3705 }
3706 int32_t ret = g_rilInterface->SetDeviceState(
3707 SLOTID_2, GetSerialId(), static_cast<int32_t>(DeviceStateType::LOW_DATA_STATE), 0);
3708 WaitFor(WAIT_TIME_SECOND);
3709 EXPECT_EQ(SUCCESS, ret);
3710 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_DEVICE_STATE));
3711 }
3712
3713 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRrcConnectionState_V1_0100, Function | MediumTest | Level3)
3714 {
3715 if (!IsReady(SLOTID_1)) {
3716 return;
3717 }
3718 int32_t ret = g_rilInterface->GetRrcConnectionState(SLOTID_1, GetSerialId());
3719 WaitFor(WAIT_TIME_SECOND);
3720 EXPECT_EQ(SUCCESS, ret);
3721 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE));
3722 }
3723
3724 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRrcConnectionState_V1_0200, Function | MediumTest | Level3)
3725 {
3726 if (!IsReady(SLOTID_2)) {
3727 return;
3728 }
3729 int32_t ret = g_rilInterface->GetRrcConnectionState(SLOTID_2, GetSerialId());
3730 WaitFor(WAIT_TIME_SECOND);
3731 EXPECT_EQ(SUCCESS, ret);
3732 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE));
3733 }
3734
3735 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNrOptionMode_V1_0100, Function | MediumTest | Level3)
3736 {
3737 if (!IsReady(SLOTID_1)) {
3738 return;
3739 }
3740 int32_t ret =
3741 g_rilInterface->SetNrOptionMode(SLOTID_1, GetSerialId(), static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA));
3742 WaitFor(WAIT_TIME_SECOND);
3743 EXPECT_EQ(SUCCESS, ret);
3744 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE));
3745 }
3746
3747 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNrOptionMode_V1_0200, Function | MediumTest | Level3)
3748 {
3749 if (!IsReady(SLOTID_2)) {
3750 return;
3751 }
3752 int32_t ret =
3753 g_rilInterface->SetNrOptionMode(SLOTID_2, GetSerialId(), static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA));
3754 WaitFor(WAIT_TIME_SECOND);
3755 EXPECT_EQ(SUCCESS, ret);
3756 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE));
3757 }
3758
3759 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNrOptionMode_V1_0100, Function | MediumTest | Level3)
3760 {
3761 if (!IsReady(SLOTID_1)) {
3762 return;
3763 }
3764 int32_t ret = g_rilInterface->GetNrOptionMode(SLOTID_1, GetSerialId());
3765 WaitFor(WAIT_TIME_SECOND);
3766 EXPECT_EQ(SUCCESS, ret);
3767 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE));
3768 }
3769
3770 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNrOptionMode_V1_0200, Function | MediumTest | Level3)
3771 {
3772 if (!IsReady(SLOTID_2)) {
3773 return;
3774 }
3775 int32_t ret = g_rilInterface->GetNrOptionMode(SLOTID_2, GetSerialId());
3776 WaitFor(WAIT_TIME_SECOND);
3777 EXPECT_EQ(SUCCESS, ret);
3778 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE));
3779 }
3780
3781 /**
3782 * modem Test
3783 **/
3784 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ShutDown_V1_0100, Function | MediumTest | Level3)
3785 {
3786 if (!IsReady(SLOTID_1)) {
3787 return;
3788 }
3789 int32_t ret = g_rilInterface->ShutDown(SLOTID_1, GetSerialId());
3790 WaitFor(WAIT_TIME_SECOND);
3791 EXPECT_EQ(SUCCESS, ret);
3792 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SHUT_DOWN));
3793 }
3794
3795 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ShutDown_V1_0200, Function | MediumTest | Level3)
3796 {
3797 if (!IsReady(SLOTID_2)) {
3798 return;
3799 }
3800 int32_t ret = g_rilInterface->ShutDown(SLOTID_2, GetSerialId());
3801 WaitFor(WAIT_TIME_SECOND);
3802 EXPECT_EQ(SUCCESS, ret);
3803 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SHUT_DOWN));
3804 }
3805
3806 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioState_V1_0100, Function | MediumTest | Level3)
3807 {
3808 if (!IsReady(SLOTID_1)) {
3809 return;
3810 }
3811 int32_t ret = g_rilInterface->SetRadioState(SLOTID_1, GetSerialId(), 1, 0);
3812 WaitFor(WAIT_TIME_SECOND);
3813 EXPECT_EQ(SUCCESS, ret);
3814 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SET_RADIO_STATUS));
3815 }
3816
3817 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioState_V1_0200, Function | MediumTest | Level3)
3818 {
3819 if (!IsReady(SLOTID_2)) {
3820 return;
3821 }
3822 int32_t ret = g_rilInterface->SetRadioState(SLOTID_1, GetSerialId(), 1, 0);
3823 WaitFor(WAIT_TIME_SECOND);
3824 EXPECT_EQ(SUCCESS, ret);
3825 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SET_RADIO_STATUS));
3826 }
3827
3828 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRadioState_V1_0100, Function | MediumTest | Level3)
3829 {
3830 if (!IsReady(SLOTID_1)) {
3831 return;
3832 }
3833 int32_t ret = g_rilInterface->GetRadioState(SLOTID_1, GetSerialId());
3834 WaitFor(WAIT_TIME_SECOND);
3835 EXPECT_EQ(SUCCESS, ret);
3836 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_RADIO_STATUS));
3837 }
3838
3839 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRadioState_V1_0200, Function | MediumTest | Level3)
3840 {
3841 if (!IsReady(SLOTID_2)) {
3842 return;
3843 }
3844 int32_t ret = g_rilInterface->GetRadioState(SLOTID_2, GetSerialId());
3845 WaitFor(WAIT_TIME_SECOND);
3846 EXPECT_EQ(SUCCESS, ret);
3847 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_RADIO_STATUS));
3848 }
3849
3850 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImei_V1_0100, Function | MediumTest | Level3)
3851 {
3852 if (!IsReady(SLOTID_1)) {
3853 return;
3854 }
3855 int32_t ret = g_rilInterface->GetImei(SLOTID_1, GetSerialId());
3856 WaitFor(WAIT_TIME_SECOND);
3857 EXPECT_EQ(SUCCESS, ret);
3858 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEI));
3859 }
3860
3861 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImei_V1_0200, Function | MediumTest | Level3)
3862 {
3863 if (!IsReady(SLOTID_2)) {
3864 return;
3865 }
3866 int32_t ret = g_rilInterface->GetImei(SLOTID_2, GetSerialId());
3867 WaitFor(WAIT_TIME_SECOND);
3868 EXPECT_EQ(SUCCESS, ret);
3869 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEI));
3870 }
3871
3872 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImeiSv_V1_0100, Function | MediumTest | Level3)
3873 {
3874 if (!IsReady(SLOTID_1)) {
3875 return;
3876 }
3877 int32_t ret = g_rilInterface->GetImeiSv(SLOTID_1, GetSerialId());
3878 WaitFor(WAIT_TIME_SECOND);
3879 EXPECT_EQ(SUCCESS, ret);
3880 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEISV));
3881 }
3882
3883 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImeiSv_V1_0200, Function | MediumTest | Level3)
3884 {
3885 if (!IsReady(SLOTID_2)) {
3886 return;
3887 }
3888 int32_t ret = g_rilInterface->GetImeiSv(SLOTID_2, GetSerialId());
3889 WaitFor(WAIT_TIME_SECOND);
3890 EXPECT_EQ(SUCCESS, ret);
3891 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEISV));
3892 }
3893
3894 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMeid_V1_0100, Function | MediumTest | Level3)
3895 {
3896 if (!IsReady(SLOTID_1)) {
3897 return;
3898 }
3899 int32_t ret = g_rilInterface->GetMeid(SLOTID_1, GetSerialId());
3900 WaitFor(WAIT_TIME_SECOND);
3901 EXPECT_EQ(SUCCESS, ret);
3902 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_MEID));
3903 }
3904
3905 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMeid_V1_0200, Function | MediumTest | Level3)
3906 {
3907 if (!IsReady(SLOTID_2)) {
3908 return;
3909 }
3910 int32_t ret = g_rilInterface->GetMeid(SLOTID_2, GetSerialId());
3911 WaitFor(WAIT_TIME_SECOND);
3912 EXPECT_EQ(SUCCESS, ret);
3913 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_MEID));
3914 }
3915
3916 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetBasebandVersion_V1_0100, Function | MediumTest | Level3)
3917 {
3918 if (!IsReady(SLOTID_1)) {
3919 return;
3920 }
3921 int32_t ret = g_rilInterface->GetBasebandVersion(SLOTID_1, GetSerialId());
3922 WaitFor(WAIT_TIME_SECOND);
3923 EXPECT_EQ(SUCCESS, ret);
3924 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_BASEBAND_VERSION));
3925 }
3926
3927 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetBasebandVersion_V1_0200, Function | MediumTest | Level3)
3928 {
3929 if (!IsReady(SLOTID_2)) {
3930 return;
3931 }
3932 int32_t ret = g_rilInterface->GetBasebandVersion(SLOTID_2, GetSerialId());
3933 WaitFor(WAIT_TIME_SECOND);
3934 EXPECT_EQ(SUCCESS, ret);
3935 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_BASEBAND_VERSION));
3936 }
3937
3938 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetVoiceRadioTechnology_V1_0100, Function | MediumTest | Level3)
3939 {
3940 if (!IsReady(SLOTID_1)) {
3941 return;
3942 }
3943 int32_t ret = g_rilInterface->GetVoiceRadioTechnology(SLOTID_1, GetSerialId());
3944 WaitFor(WAIT_TIME_SECOND);
3945 EXPECT_EQ(SUCCESS, ret);
3946 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_VOICE_RADIO));
3947 }
3948
3949 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetVoiceRadioTechnology_V1_0200, Function | MediumTest | Level3)
3950 {
3951 if (!IsReady(SLOTID_2)) {
3952 return;
3953 }
3954 int32_t ret = g_rilInterface->GetVoiceRadioTechnology(SLOTID_2, GetSerialId());
3955 WaitFor(WAIT_TIME_SECOND);
3956 EXPECT_EQ(SUCCESS, ret);
3957 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_VOICE_RADIO));
3958 }
3959
3960 // Data
3961 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ActivatePdpContext_V1_0100, Function | MediumTest | Level3)
3962 {
3963 if (!IsReady(SLOTID_1)) {
3964 return;
3965 }
3966 int32_t serialId = GetSerialId();
3967 DataProfileDataInfo dataProfileInfo;
3968 dataProfileInfo.profileId = 0;
3969 dataProfileInfo.password = "";
3970 dataProfileInfo.authenticationType = 0;
3971 dataProfileInfo.userName = "";
3972 dataProfileInfo.apn = "cmnet";
3973 dataProfileInfo.protocol = "IPV4V6";
3974 dataProfileInfo.roamingProtocol = "IPV4V6";
3975 DataCallInfo dataCallInfo;
3976 dataCallInfo.serial = serialId;
3977 dataCallInfo.radioTechnology = 0;
3978 dataCallInfo.dataProfileInfo = dataProfileInfo;
3979 dataCallInfo.roamingAllowed = true;
3980 dataCallInfo.isRoaming = false;
3981 int32_t ret = g_rilInterface->ActivatePdpContext(SLOTID_1, serialId, dataCallInfo);
3982 WaitFor(WAIT_TIME_SECOND);
3983 EXPECT_EQ(SUCCESS, ret);
3984 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT));
3985 }
3986
3987 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ActivatePdpContext_V1_0200, Function | MediumTest | Level3)
3988 {
3989 if (!IsReady(SLOTID_2)) {
3990 return;
3991 }
3992 int32_t serialId = GetSerialId();
3993 DataProfileDataInfo dataProfileInfo;
3994 dataProfileInfo.profileId = 0;
3995 dataProfileInfo.password = "";
3996 dataProfileInfo.authenticationType = 0;
3997 dataProfileInfo.userName = "";
3998 dataProfileInfo.apn = "cmnet";
3999 dataProfileInfo.protocol = "IPV4V6";
4000 dataProfileInfo.roamingProtocol = "IPV4V6";
4001 DataCallInfo dataCallInfo;
4002 dataCallInfo.serial = serialId;
4003 dataCallInfo.radioTechnology = 0;
4004 dataCallInfo.dataProfileInfo = dataProfileInfo;
4005 dataCallInfo.roamingAllowed = true;
4006 dataCallInfo.isRoaming = false;
4007 int32_t ret = g_rilInterface->ActivatePdpContext(SLOTID_2, serialId, dataCallInfo);
4008 WaitFor(WAIT_TIME_SECOND);
4009 EXPECT_EQ(SUCCESS, ret);
4010 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT));
4011 }
4012
4013 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DeactivatePdpContext_V1_0100, Function | MediumTest | Level3)
4014 {
4015 if (!IsReady(SLOTID_1)) {
4016 return;
4017 }
4018 int32_t serialId = GetSerialId();
4019 UniInfo uniInfo;
4020 uniInfo.serial = serialId;
4021 uniInfo.gsmIndex = CID;
4022 uniInfo.arg1 = REASON;
4023 int32_t ret = g_rilInterface->DeactivatePdpContext(SLOTID_1, serialId, uniInfo);
4024 WaitFor(WAIT_TIME_SECOND);
4025 EXPECT_EQ(SUCCESS, ret);
4026 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT));
4027 }
4028
4029 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DeactivatePdpContext_V1_0200, Function | MediumTest | Level3)
4030 {
4031 if (!IsReady(SLOTID_2)) {
4032 return;
4033 }
4034 int32_t serialId = GetSerialId();
4035 UniInfo uniInfo;
4036 uniInfo.serial = serialId;
4037 uniInfo.gsmIndex = CID;
4038 uniInfo.arg1 = REASON;
4039 int32_t ret = g_rilInterface->DeactivatePdpContext(SLOTID_2, serialId, uniInfo);
4040 WaitFor(WAIT_TIME_SECOND);
4041 EXPECT_EQ(SUCCESS, ret);
4042 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT));
4043 }
4044
4045 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPdpContextList_V1_0100, Function | MediumTest | Level3)
4046 {
4047 if (!IsReady(SLOTID_1)) {
4048 return;
4049 }
4050 int32_t serialId = GetSerialId();
4051 UniInfo uniInfo;
4052 uniInfo.serial = serialId;
4053 int32_t ret = g_rilInterface->GetPdpContextList(SLOTID_1, serialId, uniInfo);
4054 WaitFor(WAIT_TIME_SECOND);
4055 EXPECT_EQ(SUCCESS, ret);
4056 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST));
4057 }
4058
4059 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPdpContextList_V1_0200, Function | MediumTest | Level3)
4060 {
4061 if (!IsReady(SLOTID_2)) {
4062 return;
4063 }
4064 int32_t serialId = GetSerialId();
4065 UniInfo uniInfo;
4066 uniInfo.serial = serialId;
4067 int32_t ret = g_rilInterface->GetPdpContextList(SLOTID_2, serialId, uniInfo);
4068 WaitFor(WAIT_TIME_SECOND);
4069 EXPECT_EQ(SUCCESS, ret);
4070 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST));
4071 }
4072
4073 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetInitApnInfo_V1_0100, Function | MediumTest | Level3)
4074 {
4075 if (!IsReady(SLOTID_1)) {
4076 return;
4077 }
4078 int32_t serialId = GetSerialId();
4079 DataProfileDataInfo dataProfileInfo;
4080 dataProfileInfo.profileId = 0;
4081 dataProfileInfo.password = "";
4082 dataProfileInfo.authenticationType = 0;
4083 dataProfileInfo.userName = "";
4084 dataProfileInfo.apn = "cmnet";
4085 dataProfileInfo.protocol = "IPV4V6";
4086 dataProfileInfo.roamingProtocol = "IPV4V6";
4087 dataProfileInfo.serial = serialId;
4088 int32_t ret = g_rilInterface->SetInitApnInfo(SLOTID_1, serialId, dataProfileInfo);
4089 WaitFor(WAIT_TIME_SECOND_LONG);
4090 EXPECT_EQ(SUCCESS, ret);
4091 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_INIT_APN_INFO));
4092 }
4093
4094 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetInitApnInfo_V1_0200, Function | MediumTest | Level3)
4095 {
4096 if (!IsReady(SLOTID_2)) {
4097 return;
4098 }
4099 int32_t serialId = GetSerialId();
4100 DataProfileDataInfo dataProfileInfo;
4101 dataProfileInfo.profileId = 0;
4102 dataProfileInfo.password = "";
4103 dataProfileInfo.authenticationType = 0;
4104 dataProfileInfo.userName = "";
4105 dataProfileInfo.apn = "cmnet";
4106 dataProfileInfo.protocol = "IPV4V6";
4107 dataProfileInfo.roamingProtocol = "IPV4V6";
4108 dataProfileInfo.serial = serialId;
4109 int32_t ret = g_rilInterface->SetInitApnInfo(SLOTID_2, serialId, dataProfileInfo);
4110 WaitFor(WAIT_TIME_SECOND_LONG);
4111 EXPECT_EQ(SUCCESS, ret);
4112 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_INIT_APN_INFO));
4113 }
4114
4115 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkBandwidthInfo_V1_0100, Function | MediumTest | Level3)
4116 {
4117 if (!IsReady(SLOTID_1)) {
4118 return;
4119 }
4120 int32_t ret = g_rilInterface->GetLinkBandwidthInfo(SLOTID_1, GetSerialId(), CID);
4121 WaitFor(WAIT_TIME_SECOND);
4122 EXPECT_EQ(SUCCESS, ret);
4123 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO));
4124 }
4125
4126 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkBandwidthInfo_V1_0200, Function | MediumTest | Level3)
4127 {
4128 if (!IsReady(SLOTID_2)) {
4129 return;
4130 }
4131 int32_t ret = g_rilInterface->GetLinkBandwidthInfo(SLOTID_2, GetSerialId(), CID);
4132 WaitFor(WAIT_TIME_SECOND);
4133 EXPECT_EQ(SUCCESS, ret);
4134 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO));
4135 }
4136
4137 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLinkBandwidthReportingRule_V1_0100, Function | MediumTest | Level3)
4138 {
4139 if (!IsReady(SLOTID_1)) {
4140 return;
4141 }
4142 int32_t serialId = GetSerialId();
4143 const int32_t BANDWIDTH_HYSTERESIS_MS = 3000;
4144 const int32_t BANDWIDTH_HYSTERESIS_KBPS = 50;
4145 const int32_t MAX_UPLINK_LINK_BANDWIDTH[] = { 100, 500, 1000, 5000, 10000, 20000, 50000, 100000, 200000 };
4146 uint32_t uplinkKbpsSize = sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4147 const int32_t MAX_DOWNLINK_LINK_BANDWIDTH[] = { 100, // VoIP
4148 500, // Web
4149 1000, // SD
4150 5000, // HD
4151 10000, // file
4152 20000, // 4K
4153 50000, // LTE
4154 100000,
4155 200000, // 5G
4156 500000, 1000000 };
4157 uint32_t downlinkKbpsSize = sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4158 DataLinkBandwidthReportingRule dLinkBandwidth;
4159 dLinkBandwidth.serial = serialId;
4160 dLinkBandwidth.rat = static_cast<int32_t>(RatType::NETWORK_TYPE_LTE);
4161 dLinkBandwidth.delayMs = BANDWIDTH_HYSTERESIS_MS;
4162 dLinkBandwidth.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4163 dLinkBandwidth.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4164 dLinkBandwidth.maximumUplinkKbpsSize = uplinkKbpsSize;
4165 dLinkBandwidth.maximumDownlinkKbpsSize = downlinkKbpsSize;
4166 for (uint32_t i = 0; i < uplinkKbpsSize; i++) {
4167 dLinkBandwidth.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
4168 }
4169 for (uint32_t i = 0; i < downlinkKbpsSize; i++) {
4170 dLinkBandwidth.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
4171 }
4172 int32_t ret = g_rilInterface->SetLinkBandwidthReportingRule(SLOTID_1, GetSerialId(), dLinkBandwidth);
4173 WaitFor(WAIT_TIME_SECOND);
4174 EXPECT_EQ(SUCCESS, ret);
4175 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE));
4176 }
4177
4178 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLinkBandwidthReportingRule_V1_0200, Function | MediumTest | Level3)
4179 {
4180 if (!IsReady(SLOTID_2)) {
4181 return;
4182 }
4183 int32_t serialId = GetSerialId();
4184 const int32_t BANDWIDTH_HYSTERESIS_MS = 3000;
4185 const int32_t BANDWIDTH_HYSTERESIS_KBPS = 50;
4186 const int32_t MAX_UPLINK_LINK_BANDWIDTH[] = { 100, 500, 1000, 5000, 10000, 20000, 50000, 100000, 200000 };
4187 uint32_t uplinkKbpsSize = sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4188 const int32_t MAX_DOWNLINK_LINK_BANDWIDTH[] = { 100, // VoIP
4189 500, // Web
4190 1000, // SD
4191 5000, // HD
4192 10000, // file
4193 20000, // 4K
4194 50000, // LTE
4195 100000,
4196 200000, // 5G
4197 500000, 1000000 };
4198 uint32_t downlinkKbpsSize = sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4199 DataLinkBandwidthReportingRule dLinkBandwidth;
4200 dLinkBandwidth.serial = serialId;
4201 dLinkBandwidth.rat = static_cast<int32_t>(RatType::NETWORK_TYPE_LTE);
4202 dLinkBandwidth.delayMs = BANDWIDTH_HYSTERESIS_MS;
4203 dLinkBandwidth.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4204 dLinkBandwidth.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4205 dLinkBandwidth.maximumUplinkKbpsSize = uplinkKbpsSize;
4206 dLinkBandwidth.maximumDownlinkKbpsSize = downlinkKbpsSize;
4207 for (uint32_t i = 0; i < uplinkKbpsSize; i++) {
4208 dLinkBandwidth.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
4209 }
4210 for (uint32_t i = 0; i < downlinkKbpsSize; i++) {
4211 dLinkBandwidth.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
4212 }
4213 int32_t ret = g_rilInterface->SetLinkBandwidthReportingRule(SLOTID_2, GetSerialId(), dLinkBandwidth);
4214 WaitFor(WAIT_TIME_SECOND);
4215 EXPECT_EQ(SUCCESS, ret);
4216 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE));
4217 }
4218
4219 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataPermitted_V1_0100, Function | MediumTest | Level3)
4220 {
4221 if (!IsReady(SLOTID_1)) {
4222 return;
4223 }
4224 int32_t ret = g_rilInterface->SetDataPermitted(SLOTID_1, GetSerialId(), 1);
4225 WaitFor(WAIT_TIME_SECOND);
4226 EXPECT_EQ(SUCCESS, ret);
4227 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PERMITTED));
4228 }
4229
4230 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataPermitted_V1_0200, Function | MediumTest | Level3)
4231 {
4232 if (!IsReady(SLOTID_2)) {
4233 return;
4234 }
4235 int32_t ret = g_rilInterface->SetDataPermitted(SLOTID_2, GetSerialId(), 1);
4236 WaitFor(WAIT_TIME_SECOND);
4237 EXPECT_EQ(SUCCESS, ret);
4238 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PERMITTED));
4239 }
4240
4241 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataProfileInfo_V1_0100, Function | MediumTest | Level3)
4242 {
4243 if (!IsReady(SLOTID_1)) {
4244 return;
4245 }
4246 int32_t serialId = GetSerialId();
4247 DataProfilesInfo dataProfilesInfo;
4248 dataProfilesInfo.serial = serialId;
4249 dataProfilesInfo.profilesSize = 1;
4250 DataProfileDataInfo dataProfileInfo;
4251 dataProfileInfo.profileId = 0;
4252 dataProfileInfo.password = "";
4253 dataProfileInfo.authenticationType = 0;
4254 dataProfileInfo.userName = "";
4255 dataProfileInfo.apn = "cmnet";
4256 dataProfileInfo.protocol = "IPV4V6";
4257 dataProfileInfo.roamingProtocol = "IPV4V6";
4258 dataProfileInfo.serial = serialId;
4259 dataProfilesInfo.profiles.push_back(dataProfileInfo);
4260 int32_t ret = g_rilInterface->SetDataProfileInfo(SLOTID_1, serialId, dataProfilesInfo);
4261 WaitFor(WAIT_TIME_SECOND_LONG);
4262 EXPECT_EQ(SUCCESS, ret);
4263 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO));
4264 }
4265
4266 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataProfileInfo_V1_0200, Function | MediumTest | Level3)
4267 {
4268 if (!IsReady(SLOTID_2)) {
4269 return;
4270 }
4271 int32_t serialId = GetSerialId();
4272 DataProfilesInfo dataProfilesInfo;
4273 dataProfilesInfo.serial = serialId;
4274 dataProfilesInfo.profilesSize = 1;
4275 DataProfileDataInfo dataProfileInfo;
4276 dataProfileInfo.profileId = 0;
4277 dataProfileInfo.password = "";
4278 dataProfileInfo.authenticationType = 0;
4279 dataProfileInfo.userName = "";
4280 dataProfileInfo.apn = "cmnet";
4281 dataProfileInfo.protocol = "IPV4V6";
4282 dataProfileInfo.roamingProtocol = "IPV4V6";
4283 dataProfileInfo.serial = serialId;
4284 dataProfilesInfo.profiles.push_back(dataProfileInfo);
4285 int32_t ret = g_rilInterface->SetDataProfileInfo(SLOTID_2, serialId, dataProfilesInfo);
4286 WaitFor(WAIT_TIME_SECOND_LONG);
4287 EXPECT_EQ(SUCCESS, ret);
4288 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO));
4289 }
4290
4291 // SIM
4292 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimIO_V1_0100, Function | MediumTest | Level3)
4293 {
4294 if (!IsReady(SLOTID_1)) {
4295 return;
4296 }
4297 SimIoRequestInfo msg;
4298 msg.command = 0xc0;
4299 msg.fileId = 0x2FE2;
4300 msg.p1 = 0;
4301 msg.p2 = 0;
4302 msg.p3 = 15;
4303 msg.data = "";
4304 msg.path = "3F00";
4305 msg.pin2 = "";
4306 int32_t ret = g_rilInterface->GetSimIO(SLOTID_1, GetSerialId(), msg);
4307 WaitFor(WAIT_TIME_SECOND);
4308 EXPECT_EQ(SUCCESS, ret);
4309 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
4310 }
4311
4312 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimIO_V1_0200, Function | MediumTest | Level3)
4313 {
4314 if (!IsReady(SLOTID_2)) {
4315 return;
4316 }
4317 SimIoRequestInfo msg;
4318 msg.command = 0xC0;
4319 // ICCID
4320 msg.fileId = 0x2FE2;
4321 msg.p1 = 0;
4322 msg.p2 = 0;
4323 msg.p3 = 15;
4324 msg.data = "";
4325 msg.path = "3F00";
4326 msg.pin2 = "";
4327 int32_t ret = g_rilInterface->GetSimIO(SLOTID_2, GetSerialId(), msg);
4328 WaitFor(WAIT_TIME_SECOND);
4329 EXPECT_EQ(SUCCESS, ret);
4330 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
4331 }
4332
4333 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImsi_V1_0100, Function | MediumTest | Level3)
4334 {
4335 if (!IsReady(SLOTID_1)) {
4336 return;
4337 }
4338 int32_t ret = g_rilInterface->GetImsi(SLOTID_1, GetSerialId());
4339 WaitFor(WAIT_TIME_SECOND);
4340 EXPECT_EQ(SUCCESS, ret);
4341 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
4342 }
4343
4344 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImsi_V1_0200, Function | MediumTest | Level3)
4345 {
4346 if (!IsReady(SLOTID_2)) {
4347 return;
4348 }
4349 int32_t ret = g_rilInterface->GetImsi(SLOTID_2, GetSerialId());
4350 WaitFor(WAIT_TIME_SECOND);
4351 EXPECT_EQ(SUCCESS, ret);
4352 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
4353 }
4354
4355 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetActiveSim_V1_0100, Function | MediumTest | Level3)
4356 {
4357 if (!IsReady(SLOTID_1)) {
4358 return;
4359 }
4360 int32_t enable = 1;
4361 int32_t index = 1; // ENTITY_CARD
4362 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_1, GetSerialId(), index, enable);
4363 WaitFor(WAIT_TIME_SECOND);
4364 EXPECT_EQ(SUCCESS, ret);
4365 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
4366 }
4367
4368 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetActiveSim_V1_0200, Function | MediumTest | Level3)
4369 {
4370 if (!IsReady(SLOTID_2)) {
4371 return;
4372 }
4373 int32_t enable = 1;
4374 int32_t index = 1; // ENTITY_CARD
4375 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_2, GetSerialId(), index, enable);
4376 WaitFor(WAIT_TIME_SECOND);
4377 EXPECT_EQ(SUCCESS, ret);
4378 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
4379 }
4380
4381 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0100, Function | MediumTest | Level3)
4382 {
4383 if (!IsReady(SLOTID_1)) {
4384 return;
4385 }
4386 std::string cmd = "send terminal response";
4387 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_1, GetSerialId(), cmd);
4388 WaitFor(WAIT_TIME_SECOND);
4389 EXPECT_EQ(SUCCESS, ret);
4390 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
4391 }
4392
4393 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0200, Function | MediumTest | Level3)
4394 {
4395 if (!IsReady(SLOTID_2)) {
4396 return;
4397 }
4398 std::string cmd = "send terminal response";
4399 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_2, GetSerialId(), cmd);
4400 WaitFor(WAIT_TIME_SECOND);
4401 EXPECT_EQ(SUCCESS, ret);
4402 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
4403 }
4404
4405 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0100, Function | MediumTest | Level3)
4406 {
4407 if (!IsReady(SLOTID_1)) {
4408 return;
4409 }
4410 std::string cmd = "send envelope";
4411 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_1, GetSerialId(), cmd);
4412 WaitFor(WAIT_TIME_SECOND);
4413 EXPECT_EQ(SUCCESS, ret);
4414 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
4415 }
4416
4417 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0200, Function | MediumTest | Level3)
4418 {
4419 if (!IsReady(SLOTID_2)) {
4420 return;
4421 }
4422 std::string cmd = "send envelope";
4423 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_2, GetSerialId(), cmd);
4424 WaitFor(WAIT_TIME_SECOND);
4425 EXPECT_EQ(SUCCESS, ret);
4426 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
4427 }
4428
4429 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0100, Function | MediumTest | Level3)
4430 {
4431 if (!IsReady(SLOTID_1)) {
4432 return;
4433 }
4434 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_1, GetSerialId(), true);
4435 WaitFor(WAIT_TIME_SECOND);
4436 EXPECT_EQ(SUCCESS, ret);
4437 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
4438 }
4439
4440 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0200, Function | MediumTest | Level3)
4441 {
4442 if (!IsReady(SLOTID_2)) {
4443 return;
4444 }
4445 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_2, GetSerialId(), true);
4446 WaitFor(WAIT_TIME_SECOND);
4447 EXPECT_EQ(SUCCESS, ret);
4448 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
4449 }
4450
4451 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkIsReady_V1_0100, Function | MediumTest | Level3)
4452 {
4453 if (!IsReady(SLOTID_1)) {
4454 return;
4455 }
4456 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_1, GetSerialId());
4457 WaitFor(WAIT_TIME_SECOND);
4458 EXPECT_EQ(SUCCESS, ret);
4459 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
4460 }
4461
4462 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkIsReady_V1_0200, Function | MediumTest | Level3)
4463 {
4464 if (!IsReady(SLOTID_2)) {
4465 return;
4466 }
4467 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_2, GetSerialId());
4468 WaitFor(WAIT_TIME_SECOND);
4469 EXPECT_EQ(SUCCESS, ret);
4470 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
4471 }
4472
4473 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioProtocol_V1_0100, Function | MediumTest | Level3)
4474 {
4475 if (!IsReady(SLOTID_1)) {
4476 return;
4477 }
4478 RadioProtocol protocol;
4479 protocol.slotId = SLOTID_1;
4480 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_1, GetSerialId(), protocol);
4481 WaitFor(WAIT_TIME_SECOND);
4482 EXPECT_EQ(SUCCESS, ret);
4483 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
4484 }
4485
4486 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioProtocol_V1_0200, Function | MediumTest | Level3)
4487 {
4488 if (!IsReady(SLOTID_2)) {
4489 return;
4490 }
4491 RadioProtocol protocol;
4492 protocol.slotId = SLOTID_2;
4493 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_2, GetSerialId(), protocol);
4494 WaitFor(WAIT_TIME_SECOND);
4495 EXPECT_EQ(SUCCESS, ret);
4496 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
4497 }
4498
4499 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0100, Function | MediumTest | Level3)
4500 {
4501 if (!IsReady(SLOTID_1)) {
4502 return;
4503 }
4504 std::string appID = "A00000015141434C00"; // ARAM_AID
4505 int32_t p2 = 0;
4506 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_1, GetSerialId(), appID, p2);
4507 WaitFor(WAIT_TIME_SECOND);
4508 EXPECT_EQ(SUCCESS, ret);
4509 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
4510 }
4511
4512 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0100, Function | MediumTest | Level3)
4513 {
4514 if (!IsReady(SLOTID_1)) {
4515 return;
4516 }
4517 ApduSimIORequestInfo reqInfo;
4518 reqInfo.channelId = currentChannelId_;
4519 reqInfo.type = 0x80; // CLA
4520 reqInfo.instruction = 0xCA; // COMMAND;
4521 reqInfo.p1 = 0xFF;
4522 reqInfo.p2 = 0x40;
4523 reqInfo.p3 = 0x00;
4524 reqInfo.data = "";
4525 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_1, GetSerialId(), reqInfo);
4526 WaitFor(WAIT_TIME_SECOND);
4527 EXPECT_EQ(SUCCESS, ret);
4528 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
4529 }
4530
4531 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100, Function | MediumTest | Level3)
4532 {
4533 if (!IsReady(SLOTID_1)) {
4534 return;
4535 }
4536 int32_t ret = g_rilInterface->SimCloseLogicalChannel(SLOTID_1, GetSerialId(), currentChannelId_);
4537 WaitFor(WAIT_TIME_SECOND);
4538 EXPECT_EQ(SUCCESS, ret);
4539 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
4540 }
4541
4542 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0200, Function | MediumTest | Level3)
4543 {
4544 if (!IsReady(SLOTID_2)) {
4545 return;
4546 }
4547 std::string appID = "A00000015141434C00"; // ARAM_AID
4548 int32_t p2 = 0;
4549 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_2, GetSerialId(), appID, p2);
4550 WaitFor(WAIT_TIME_SECOND);
4551 EXPECT_EQ(SUCCESS, ret);
4552 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
4553 }
4554
4555 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0200, Function | MediumTest | Level3)
4556 {
4557 if (!IsReady(SLOTID_2)) {
4558 return;
4559 }
4560 ApduSimIORequestInfo reqInfo;
4561 reqInfo.channelId = currentChannelId_;
4562 reqInfo.type = 0x80; // CLA
4563 reqInfo.instruction = 0xCA; // COMMAND;
4564 reqInfo.p1 = 0xFF;
4565 reqInfo.p2 = 0x40;
4566 reqInfo.p3 = 0x00;
4567 reqInfo.data = "";
4568 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_2, GetSerialId(), reqInfo);
4569 WaitFor(WAIT_TIME_SECOND);
4570 EXPECT_EQ(SUCCESS, ret);
4571 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
4572 }
4573
4574 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0200, Function | MediumTest | Level3)
4575 {
4576 if (!IsReady(SLOTID_2)) {
4577 return;
4578 }
4579 int32_t ret = g_rilInterface->SimCloseLogicalChannel(SLOTID_2, GetSerialId(), currentChannelId_);
4580 WaitFor(WAIT_TIME_SECOND);
4581 EXPECT_EQ(SUCCESS, ret);
4582 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
4583 }
4584
4585 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0100, Function | MediumTest | Level3)
4586 {
4587 if (!IsReady(SLOTID_1)) {
4588 return;
4589 }
4590 ApduSimIORequestInfo reqInfo;
4591 reqInfo.type = 0x80; // CLA
4592 reqInfo.instruction = 0xCA; // COMMAND;
4593 reqInfo.p1 = 0xFF;
4594 reqInfo.p2 = 0x40;
4595 reqInfo.p3 = 0x00;
4596 reqInfo.data = "";
4597 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_1, GetSerialId(), reqInfo);
4598 WaitFor(WAIT_TIME_SECOND);
4599 EXPECT_EQ(SUCCESS, ret);
4600 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
4601 }
4602
4603 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0200, Function | MediumTest | Level3)
4604 {
4605 if (!IsReady(SLOTID_2)) {
4606 return;
4607 }
4608 ApduSimIORequestInfo reqInfo;
4609 reqInfo.type = 0x80; // CLA
4610 reqInfo.instruction = 0xCA; // COMMAND;
4611 reqInfo.p1 = 0xFF;
4612 reqInfo.p2 = 0x40;
4613 reqInfo.p3 = 0x00;
4614 reqInfo.data = "";
4615 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_2, GetSerialId(), reqInfo);
4616 WaitFor(WAIT_TIME_SECOND);
4617 EXPECT_EQ(SUCCESS, ret);
4618 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
4619 }
4620
4621 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimAuthentication_V1_0100, Function | MediumTest | Level3)
4622 {
4623 if (!IsReady(SLOTID_1)) {
4624 return;
4625 }
4626 SimAuthenticationRequestInfo simAuthInfo;
4627 simAuthInfo.aid = "aid";
4628 simAuthInfo.authData = "authData";
4629 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_1, GetSerialId(), simAuthInfo);
4630 WaitFor(WAIT_TIME_SECOND);
4631 EXPECT_EQ(SUCCESS, ret);
4632 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
4633 }
4634
4635 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimAuthentication_V1_0200, Function | MediumTest | Level3)
4636 {
4637 if (!IsReady(SLOTID_2)) {
4638 return;
4639 }
4640 SimAuthenticationRequestInfo simAuthInfo;
4641 simAuthInfo.aid = "aid";
4642 simAuthInfo.authData = "authData";
4643 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_2, GetSerialId(), simAuthInfo);
4644 WaitFor(WAIT_TIME_SECOND);
4645 EXPECT_EQ(SUCCESS, ret);
4646 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
4647 }
4648
4649 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimLockStatus_V1_0100, Function | MediumTest | Level3)
4650 {
4651 #ifdef TEL_TEST_PIN_PUK
4652 if (!IsReady(SLOTID_1)) {
4653 return;
4654 }
4655 SimLockInfo simLockInfo;
4656 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4657 simLockInfo.mode = 2; // MODE
4658 simLockInfo.classx = 0;
4659 constexpr const char *FAC_PIN_LOCK = "SC";
4660 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_1, GetSerialId(), simLockInfo);
4661 WaitFor(WAIT_TIME_SECOND);
4662 EXPECT_EQ(SUCCESS, ret);
4663 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
4664 #endif
4665 ASSERT_TRUE(true);
4666 }
4667
4668 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimLockStatus_V1_0200, Function | MediumTest | Level3)
4669 {
4670 #ifdef TEL_TEST_PIN_PUK
4671 if (!IsReady(SLOTID_2)) {
4672 return;
4673 }
4674 SimLockInfo simLockInfo;
4675 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4676 simLockInfo.mode = 2; // MODE
4677 simLockInfo.classx = 0;
4678 constexpr const char *FAC_PIN_LOCK = "SC";
4679 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_2, GetSerialId(), simLockInfo);
4680 WaitFor(WAIT_TIME_SECOND);
4681 EXPECT_EQ(SUCCESS, ret);
4682 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
4683 #endif
4684 ASSERT_TRUE(true);
4685 }
4686
4687 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSimLock_V1_0100, Function | MediumTest | Level3)
4688 {
4689 #ifdef TEL_TEST_PIN_PUK
4690 if (!IsReady(SLOTID_1)) {
4691 return;
4692 }
4693 SimLockInfo simLockInfo;
4694 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4695 simLockInfo.mode = 2; // MODE
4696 simLockInfo.classx = 0;
4697 simLockInfo.passwd = "1234";
4698 constexpr const char *FAC_PIN_LOCK = "SC";
4699 int32_t ret = g_rilInterface->SetSimLock(SLOTID_1, GetSerialId(), simLockInfo);
4700 WaitFor(WAIT_TIME_SECOND);
4701 EXPECT_EQ(SUCCESS, ret);
4702 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
4703 #endif
4704 ASSERT_TRUE(true);
4705 }
4706
4707 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSimLock_V1_0200, Function | MediumTest | Level3)
4708 {
4709 #ifdef TEL_TEST_PIN_PUK
4710 if (!IsReady(SLOTID_2)) {
4711 return;
4712 }
4713 SimLockInfo simLockInfo;
4714 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4715 simLockInfo.mode = 2; // MODE
4716 simLockInfo.classx = 0;
4717 simLockInfo.passwd = "1234";
4718 constexpr const char *FAC_PIN_LOCK = "SC";
4719 int32_t ret = g_rilInterface->SetSimLock(SLOTID_2, GetSerialId(), simLockInfo);
4720 WaitFor(WAIT_TIME_SECOND);
4721 EXPECT_EQ(SUCCESS, ret);
4722 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
4723 #endif
4724 ASSERT_TRUE(true);
4725 }
4726
4727 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ChangeSimPassword_V1_0100, Function | MediumTest | Level3)
4728 {
4729 #ifdef TEL_TEST_PIN_PUK
4730 if (!IsReady(SLOTID_1)) {
4731 return;
4732 }
4733 ISimPasswordInfo simPassword;
4734 simPassword.fac = "SC"; // FAC_PIN_LOCK
4735 simPassword.oldPassword = "1234";
4736 simPassword.newPassword = "1234";
4737 simPassword.passwordLength = 4;
4738 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_1, GetSerialId(), simPassword);
4739 WaitFor(WAIT_TIME_SECOND);
4740 EXPECT_EQ(SUCCESS, ret);
4741 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
4742 #endif
4743 ASSERT_TRUE(true);
4744 }
4745
4746 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ChangeSimPassword_V1_0200, Function | MediumTest | Level3)
4747 {
4748 #ifdef TEL_TEST_PIN_PUK
4749 if (!IsReady(SLOTID_2)) {
4750 return;
4751 }
4752 ISimPasswordInfo simPassword;
4753 simPassword.fac = "SC"; // FAC_PIN_LOCK
4754 simPassword.oldPassword = "1234";
4755 simPassword.newPassword = "1234";
4756 simPassword.passwordLength = 4;
4757 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_2, GetSerialId(), simPassword);
4758 WaitFor(WAIT_TIME_SECOND);
4759 EXPECT_EQ(SUCCESS, ret);
4760 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
4761 #endif
4762 ASSERT_TRUE(true);
4763 }
4764
4765 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin_V1_0100, Function | MediumTest | Level3)
4766 {
4767 #ifdef TEL_TEST_PIN_PUK
4768 if (!IsReady(SLOTID_1)) {
4769 return;
4770 }
4771 std::string pin = "1234";
4772 int32_t ret = g_rilInterface->UnlockPin(SLOTID_1, GetSerialId(), pin);
4773 WaitFor(WAIT_TIME_SECOND);
4774 EXPECT_EQ(SUCCESS, ret);
4775 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
4776 #endif
4777 ASSERT_TRUE(true);
4778 }
4779
4780 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin_V1_0200, Function | MediumTest | Level3)
4781 {
4782 #ifdef TEL_TEST_PIN_PUK
4783 if (!IsReady(SLOTID_2)) {
4784 return;
4785 }
4786 std::string pin = "1234";
4787 int32_t ret = g_rilInterface->UnlockPin(SLOTID_2, GetSerialId(), pin);
4788 WaitFor(WAIT_TIME_SECOND);
4789 EXPECT_EQ(SUCCESS, ret);
4790 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
4791 #endif
4792 ASSERT_TRUE(true);
4793 }
4794
4795 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk_V1_0100, Function | MediumTest | Level3)
4796 {
4797 #ifdef TEL_TEST_PIN_PUK
4798 if (!IsReady(SLOTID_1)) {
4799 return;
4800 }
4801 std::string puk = "42014264";
4802 std::string pin = "1234";
4803 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_1, GetSerialId(), puk, pin);
4804 WaitFor(WAIT_TIME_SECOND);
4805 EXPECT_EQ(SUCCESS, ret);
4806 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
4807 #endif
4808 ASSERT_TRUE(true);
4809 }
4810
4811 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk_V1_0200, Function | MediumTest | Level3)
4812 {
4813 #ifdef TEL_TEST_PIN_PUK
4814 if (!IsReady(SLOTID_2)) {
4815 return;
4816 }
4817 std::string puk = "42014264";
4818 std::string pin = "1234";
4819 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_2, GetSerialId(), puk, pin);
4820 WaitFor(WAIT_TIME_SECOND);
4821 EXPECT_EQ(SUCCESS, ret);
4822 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
4823 #endif
4824 ASSERT_TRUE(true);
4825 }
4826
4827 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin2_V1_0100, Function | MediumTest | Level3)
4828 {
4829 #ifdef TEL_TEST_PIN_PUK
4830 if (!IsReady(SLOTID_1)) {
4831 return;
4832 }
4833 std::string pin2 = "1234";
4834 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_1, GetSerialId(), pin2);
4835 WaitFor(WAIT_TIME_SECOND);
4836 EXPECT_EQ(SUCCESS, ret);
4837 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
4838 #endif
4839 ASSERT_TRUE(true);
4840 }
4841
4842 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin2_V1_0200, Function | MediumTest | Level3)
4843 {
4844 #ifdef TEL_TEST_PIN_PUK
4845 if (!IsReady(SLOTID_2)) {
4846 return;
4847 }
4848 std::string pin2 = "1234";
4849 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_2, GetSerialId(), pin2);
4850 WaitFor(WAIT_TIME_SECOND);
4851 EXPECT_EQ(SUCCESS, ret);
4852 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
4853 #endif
4854 ASSERT_TRUE(true);
4855 }
4856
4857 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk2_V1_0100, Function | MediumTest | Level3)
4858 {
4859 #ifdef TEL_TEST_PIN_PUK
4860 if (!IsReady(SLOTID_1)) {
4861 return;
4862 }
4863 std::string puk2 = "42014264";
4864 std::string pin2 = "1234";
4865 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_1, GetSerialId(), puk2, pin2);
4866 WaitFor(WAIT_TIME_SECOND);
4867 EXPECT_EQ(SUCCESS, ret);
4868 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
4869 #endif
4870 ASSERT_TRUE(true);
4871 }
4872
4873 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk2_V1_0200, Function | MediumTest | Level3)
4874 {
4875 #ifdef TEL_TEST_PIN_PUK
4876 if (!IsReady(SLOTID_2)) {
4877 return;
4878 }
4879 std::string puk2 = "42014264";
4880 std::string pin2 = "1234";
4881 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_2, GetSerialId(), puk2, pin2);
4882 WaitFor(WAIT_TIME_SECOND);
4883 EXPECT_EQ(SUCCESS, ret);
4884 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
4885 #endif
4886 ASSERT_TRUE(true);
4887 }
4888
4889 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockSimLock_V1_0100, Function | MediumTest | Level3)
4890 {
4891 #ifdef TEL_TEST_PIN_PUK
4892 if (!IsReady(SLOTID_1)) {
4893 return;
4894 }
4895 int32_t lockType = 0;
4896 std::string key = "1234"; // PN_PIN_LOCK
4897 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_1, GetSerialId(), lockType, key);
4898 WaitFor(WAIT_TIME_SECOND);
4899 EXPECT_EQ(SUCCESS, ret);
4900 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
4901 #endif
4902 ASSERT_TRUE(true);
4903 }
4904
4905 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockSimLock_V1_0200, Function | MediumTest | Level3)
4906 {
4907 #ifdef TEL_TEST_PIN_PUK
4908 if (!IsReady(SLOTID_2)) {
4909 return;
4910 }
4911 int32_t lockType = 0;
4912 std::string key = "1234"; // PN_PIN_LOCK
4913 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_2, GetSerialId(), lockType, key);
4914 WaitFor(WAIT_TIME_SECOND);
4915 EXPECT_EQ(SUCCESS, ret);
4916 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
4917 #endif
4918 ASSERT_TRUE(true);
4919 }
4920
4921 // Sms
4922 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddSimMessage_V1_0100, Function | MediumTest | Level3)
4923 {
4924 if (!IsReady(SLOTID_1)) {
4925 return;
4926 }
4927 SmsMessageIOInfo msgIoInfo;
4928 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4929 msgIoInfo.pdu = TEST_STORAGE_PDU;
4930 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4931 int32_t ret = g_rilInterface->AddSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4932 WaitFor(WAIT_TIME_SECOND_LONG);
4933 EXPECT_EQ(SUCCESS, ret);
4934 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_SIM_MESSAGE));
4935 }
4936
4937 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddSimMessage_V1_0200, Function | MediumTest | Level3)
4938 {
4939 if (!IsReady(SLOTID_2)) {
4940 return;
4941 }
4942 SmsMessageIOInfo msgIoInfo;
4943 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4944 msgIoInfo.pdu = TEST_STORAGE_PDU;
4945 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4946 int32_t ret = g_rilInterface->AddSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4947 WaitFor(WAIT_TIME_SECOND_LONG);
4948 EXPECT_EQ(SUCCESS, ret);
4949 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_SIM_MESSAGE));
4950 }
4951
4952 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateSimMessage_V1_0100, Function | MediumTest | Level3)
4953 {
4954 if (!IsReady(SLOTID_1)) {
4955 return;
4956 }
4957 SmsMessageIOInfo msgIoInfo;
4958 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4959 msgIoInfo.pdu = TEST_STORAGE_PDU;
4960 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4961 msgIoInfo.index = 0;
4962 int32_t ret = g_rilInterface->UpdateSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4963 WaitFor(WAIT_TIME_SECOND_LONG);
4964 EXPECT_EQ(SUCCESS, ret);
4965 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE));
4966 }
4967
4968 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateSimMessage_V1_0200, Function | MediumTest | Level3)
4969 {
4970 if (!IsReady(SLOTID_2)) {
4971 return;
4972 }
4973 SmsMessageIOInfo msgIoInfo;
4974 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4975 msgIoInfo.pdu = TEST_STORAGE_PDU;
4976 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4977 msgIoInfo.index = 0;
4978 int32_t ret = g_rilInterface->UpdateSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4979 WaitFor(WAIT_TIME_SECOND_LONG);
4980 EXPECT_EQ(SUCCESS, ret);
4981 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE));
4982 }
4983
4984 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelSimMessage_V1_0100, Function | MediumTest | Level3)
4985 {
4986 if (!IsReady(SLOTID_1)) {
4987 return;
4988 }
4989 int32_t index = 0;
4990 int32_t ret = g_rilInterface->DelSimMessage(SLOTID_1, GetSerialId(), index);
4991 WaitFor(WAIT_TIME_SECOND_LONG);
4992 EXPECT_EQ(SUCCESS, ret);
4993 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_SIM_MESSAGE));
4994 }
4995
4996 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelSimMessage_V1_0200, Function | MediumTest | Level3)
4997 {
4998 if (!IsReady(SLOTID_2)) {
4999 return;
5000 }
5001 int32_t index = 0;
5002 int32_t ret = g_rilInterface->DelSimMessage(SLOTID_2, GetSerialId(), index);
5003 WaitFor(WAIT_TIME_SECOND_LONG);
5004 EXPECT_EQ(SUCCESS, ret);
5005 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_SIM_MESSAGE));
5006 }
5007
5008 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
5009 {
5010 if (!IsReady(SLOTID_1)) {
5011 return;
5012 }
5013 SmsMessageIOInfo msgIoInfo;
5014 msgIoInfo.smscPdu = TEST_SMSC_PDU;
5015 msgIoInfo.pdu = TEST_STORAGE_PDU;
5016 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
5017 int32_t ret = g_rilInterface->AddCdmaSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
5018 WaitFor(WAIT_TIME_SECOND_LONG);
5019 EXPECT_EQ(SUCCESS, ret);
5020 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE));
5021 }
5022
5023 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
5024 {
5025 if (!IsReady(SLOTID_2)) {
5026 return;
5027 }
5028 SmsMessageIOInfo msgIoInfo;
5029 msgIoInfo.smscPdu = TEST_SMSC_PDU;
5030 msgIoInfo.pdu = TEST_STORAGE_PDU;
5031 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
5032 int32_t ret = g_rilInterface->AddCdmaSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
5033 WaitFor(WAIT_TIME_SECOND_LONG);
5034 EXPECT_EQ(SUCCESS, ret);
5035 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE));
5036 }
5037
5038 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
5039 {
5040 if (!IsReady(SLOTID_1)) {
5041 return;
5042 }
5043 SmsMessageIOInfo msgIoInfo;
5044 msgIoInfo.smscPdu = TEST_SMSC_PDU;
5045 msgIoInfo.pdu = TEST_STORAGE_PDU;
5046 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
5047 msgIoInfo.index = 0;
5048 int32_t ret = g_rilInterface->UpdateCdmaSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
5049 WaitFor(WAIT_TIME_SECOND_LONG);
5050 EXPECT_EQ(SUCCESS, ret);
5051 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE));
5052 }
5053
5054 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
5055 {
5056 if (!IsReady(SLOTID_2)) {
5057 return;
5058 }
5059 SmsMessageIOInfo msgIoInfo;
5060 msgIoInfo.smscPdu = TEST_SMSC_PDU;
5061 msgIoInfo.pdu = TEST_STORAGE_PDU;
5062 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
5063 msgIoInfo.index = 0;
5064 int32_t ret = g_rilInterface->UpdateCdmaSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
5065 WaitFor(WAIT_TIME_SECOND_LONG);
5066 EXPECT_EQ(SUCCESS, ret);
5067 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE));
5068 }
5069
5070 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
5071 {
5072 if (!IsReady(SLOTID_1)) {
5073 return;
5074 }
5075 int32_t index = 0;
5076 int32_t ret = g_rilInterface->DelCdmaSimMessage(SLOTID_1, GetSerialId(), index);
5077 WaitFor(WAIT_TIME_SECOND_LONG);
5078 EXPECT_EQ(SUCCESS, ret);
5079 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE));
5080 }
5081
5082 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
5083 {
5084 if (!IsReady(SLOTID_2)) {
5085 return;
5086 }
5087 int32_t index = 0;
5088 int32_t ret = g_rilInterface->DelCdmaSimMessage(SLOTID_2, GetSerialId(), index);
5089 WaitFor(WAIT_TIME_SECOND_LONG);
5090 EXPECT_EQ(SUCCESS, ret);
5091 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE));
5092 }
5093
5094 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSmscAddr_V1_0100, Function | MediumTest | Level3)
5095 {
5096 if (!IsReady(SLOTID_1)) {
5097 return;
5098 }
5099 ServiceCenterAddress address;
5100 address.address = TEST_SMSC_ADDR;
5101 address.tosca = TEST_TOSCA;
5102 int32_t ret = g_rilInterface->SetSmscAddr(SLOTID_1, GetSerialId(), address);
5103 WaitFor(WAIT_TIME_SECOND_LONG);
5104 EXPECT_EQ(SUCCESS, ret);
5105 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_SMSC_ADDR));
5106 }
5107
5108 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSmscAddr_V1_0200, Function | MediumTest | Level3)
5109 {
5110 if (!IsReady(SLOTID_2)) {
5111 return;
5112 }
5113 ServiceCenterAddress address;
5114 address.address = TEST_SMSC_ADDR;
5115 address.tosca = TEST_TOSCA;
5116 int32_t ret = g_rilInterface->SetSmscAddr(SLOTID_2, GetSerialId(), address);
5117 WaitFor(WAIT_TIME_SECOND_LONG);
5118 EXPECT_EQ(SUCCESS, ret);
5119 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_SMSC_ADDR));
5120 }
5121
5122 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSmscAddr_V1_0100, Function | MediumTest | Level3)
5123 {
5124 if (!IsReady(SLOTID_1)) {
5125 return;
5126 }
5127 int32_t ret = g_rilInterface->GetSmscAddr(SLOTID_1, GetSerialId());
5128 WaitFor(WAIT_TIME_SECOND_LONG);
5129 EXPECT_EQ(SUCCESS, ret);
5130 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_SMSC_ADDR));
5131 }
5132
5133 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSmscAddr_V1_0200, Function | MediumTest | Level3)
5134 {
5135 if (!IsReady(SLOTID_2)) {
5136 return;
5137 }
5138 int32_t ret = g_rilInterface->GetSmscAddr(SLOTID_2, GetSerialId());
5139 WaitFor(WAIT_TIME_SECOND_LONG);
5140 EXPECT_EQ(SUCCESS, ret);
5141 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_SMSC_ADDR));
5142 }
5143
5144 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCBConfig_V1_0100, Function | MediumTest | Level3)
5145 {
5146 if (!IsReady(SLOTID_1)) {
5147 return;
5148 }
5149 int32_t GSM_TYPE = 1;
5150 CBConfigInfo info;
5151 info.mode = GSM_TYPE;
5152 info.mids = TEST_ID_LIST;
5153 info.dcss = TEST_DCS_LIST;
5154 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
5155 WaitFor(WAIT_TIME_SECOND_LONG);
5156 EXPECT_EQ(SUCCESS, ret);
5157 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CB_CONFIG));
5158 }
5159
5160 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCBConfig_V1_0200, Function | MediumTest | Level3)
5161 {
5162 if (!IsReady(SLOTID_2)) {
5163 return;
5164 }
5165 int32_t GSM_TYPE = 1;
5166 CBConfigInfo info;
5167 info.mode = GSM_TYPE;
5168 info.mids = TEST_ID_LIST;
5169 info.dcss = TEST_DCS_LIST;
5170 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_2, GetSerialId(), info);
5171 WaitFor(WAIT_TIME_SECOND_LONG);
5172 EXPECT_EQ(SUCCESS, ret);
5173 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CB_CONFIG));
5174 }
5175
5176 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCBConfig_V1_0100, Function | MediumTest | Level3)
5177 {
5178 if (!IsReady(SLOTID_1)) {
5179 return;
5180 }
5181 int32_t ret = g_rilInterface->GetCBConfig(SLOTID_1, GetSerialId());
5182 WaitFor(WAIT_TIME_SECOND_LONG);
5183 EXPECT_EQ(SUCCESS, ret);
5184 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CB_CONFIG));
5185 }
5186
5187 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCBConfig_V1_0200, Function | MediumTest | Level3)
5188 {
5189 if (!IsReady(SLOTID_2)) {
5190 return;
5191 }
5192 int32_t ret = g_rilInterface->GetCBConfig(SLOTID_2, GetSerialId());
5193 WaitFor(WAIT_TIME_SECOND_LONG);
5194 EXPECT_EQ(SUCCESS, ret);
5195 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CB_CONFIG));
5196 }
5197
5198 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCdmaCBConfig_V1_0100, Function | MediumTest | Level3)
5199 {
5200 if (!IsReady(SLOTID_1)) {
5201 return;
5202 }
5203 CdmaCBConfigInfoList broadcastInfoList = {};
5204 int32_t ret = g_rilInterface->SetCdmaCBConfig(SLOTID_1, GetSerialId(), broadcastInfoList);
5205 WaitFor(WAIT_TIME_SECOND_LONG);
5206 EXPECT_EQ(SUCCESS, ret);
5207 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG));
5208 }
5209
5210 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCdmaCBConfig_V1_0200, Function | MediumTest | Level3)
5211 {
5212 if (!IsReady(SLOTID_2)) {
5213 return;
5214 }
5215 CdmaCBConfigInfoList broadcastInfoList = {};
5216 int32_t ret = g_rilInterface->SetCdmaCBConfig(SLOTID_2, GetSerialId(), broadcastInfoList);
5217 WaitFor(WAIT_TIME_SECOND_LONG);
5218 EXPECT_EQ(SUCCESS, ret);
5219 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG));
5220 }
5221
5222 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCdmaCBConfig_V1_0100, Function | MediumTest | Level3)
5223 {
5224 if (!IsReady(SLOTID_1)) {
5225 return;
5226 }
5227 int32_t ret = g_rilInterface->GetCdmaCBConfig(SLOTID_1, GetSerialId());
5228 WaitFor(WAIT_TIME_SECOND_LONG);
5229 EXPECT_EQ(SUCCESS, ret);
5230 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG));
5231 }
5232
5233 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCdmaCBConfig_V1_0200, Function | MediumTest | Level3)
5234 {
5235 if (!IsReady(SLOTID_2)) {
5236 return;
5237 }
5238 int32_t ret = g_rilInterface->GetCdmaCBConfig(SLOTID_2, GetSerialId());
5239 WaitFor(WAIT_TIME_SECOND_LONG);
5240 EXPECT_EQ(SUCCESS, ret);
5241 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG));
5242 }
5243
5244 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsMoreMode_V1_0100, Function | MediumTest | Level3)
5245 {
5246 if (!IsReady(SLOTID_1)) {
5247 return;
5248 }
5249 GsmSmsMessageInfo msg;
5250 msg.smscPdu = TEST_SMSC_PDU;
5251 msg.pdu = TEST_SEND_PDU;
5252 int32_t ret = g_rilInterface->SendSmsMoreMode(SLOTID_1, GetSerialId(), msg);
5253 WaitFor(WAIT_TIME_SECOND_LONG);
5254 EXPECT_EQ(SUCCESS, ret);
5255 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_MORE_MODE));
5256 }
5257
5258 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsMoreMode_V1_0200, Function | MediumTest | Level3)
5259 {
5260 if (!IsReady(SLOTID_2)) {
5261 return;
5262 }
5263 GsmSmsMessageInfo msg;
5264 msg.smscPdu = TEST_SMSC_PDU;
5265 msg.pdu = TEST_SEND_PDU;
5266 int32_t ret = g_rilInterface->SendSmsMoreMode(SLOTID_2, GetSerialId(), msg);
5267 WaitFor(WAIT_TIME_SECOND_LONG);
5268 EXPECT_EQ(SUCCESS, ret);
5269 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_MORE_MODE));
5270 }
5271
5272 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsAck_V1_0100, Function | MediumTest | Level3)
5273 {
5274 if (!IsReady(SLOTID_1)) {
5275 return;
5276 }
5277 ModeData data;
5278 data.result = TEST_RESULT;
5279 data.mode = TEST_MODE;
5280 int32_t ret = g_rilInterface->SendSmsAck(SLOTID_1, GetSerialId(), data);
5281 WaitFor(WAIT_TIME_SECOND_LONG);
5282 EXPECT_EQ(SUCCESS, ret);
5283 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_ACK));
5284 }
5285
5286 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsAck_V1_0200, Function | MediumTest | Level3)
5287 {
5288 if (!IsReady(SLOTID_2)) {
5289 return;
5290 }
5291 ModeData data;
5292 data.result = TEST_RESULT;
5293 data.mode = TEST_MODE;
5294 int32_t ret = g_rilInterface->SendSmsAck(SLOTID_2, GetSerialId(), data);
5295 WaitFor(WAIT_TIME_SECOND_LONG);
5296 EXPECT_EQ(SUCCESS, ret);
5297 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_ACK));
5298 }
5299
5300 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendGsmSms_V1_0100, Function | MediumTest | Level3)
5301 {
5302 if (!IsReady(SLOTID_1)) {
5303 return;
5304 }
5305 GsmSmsMessageInfo msg;
5306 msg.smscPdu = TEST_SMSC_PDU;
5307 msg.pdu = TEST_SEND_PDU;
5308 int32_t ret = g_rilInterface->SendGsmSms(SLOTID_1, GetSerialId(), msg);
5309 WaitFor(WAIT_TIME_SECOND_LONG);
5310 EXPECT_EQ(SUCCESS, ret);
5311 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_GSM_SMS));
5312 }
5313
5314 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendGsmSms_V1_0200, Function | MediumTest | Level3)
5315 {
5316 if (!IsReady(SLOTID_2)) {
5317 return;
5318 }
5319 GsmSmsMessageInfo msg;
5320 msg.smscPdu = TEST_SMSC_PDU;
5321 msg.pdu = TEST_SEND_PDU;
5322 int32_t ret = g_rilInterface->SendGsmSms(SLOTID_2, GetSerialId(), msg);
5323 WaitFor(WAIT_TIME_SECOND_LONG);
5324 EXPECT_EQ(SUCCESS, ret);
5325 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_GSM_SMS));
5326 }
5327
5328 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendCdmaSms_V1_0100, Function | MediumTest | Level3)
5329 {
5330 if (!IsReady(SLOTID_1)) {
5331 return;
5332 }
5333 SendCdmaSmsMessageInfo msg;
5334 msg.smscPdu = TEST_CDMA_PDU;
5335 int32_t ret = g_rilInterface->SendCdmaSms(SLOTID_1, GetSerialId(), msg);
5336 WaitFor(WAIT_TIME_SECOND_LONG);
5337 EXPECT_EQ(SUCCESS, ret);
5338 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_CDMA_SMS));
5339 }
5340
5341 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendCdmaSms_V1_0200, Function | MediumTest | Level3)
5342 {
5343 if (!IsReady(SLOTID_2)) {
5344 return;
5345 }
5346 SendCdmaSmsMessageInfo msg;
5347 msg.smscPdu = TEST_CDMA_PDU;
5348 int32_t ret = g_rilInterface->SendCdmaSms(SLOTID_2, GetSerialId(), msg);
5349 WaitFor(WAIT_TIME_SECOND_LONG);
5350 EXPECT_EQ(SUCCESS, ret);
5351 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_CDMA_SMS));
5352 }
5353
5354 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataSleepMode_V1_0100, Function | MediumTest | Level3)
5355 {
5356 if (!IsReady(SLOTID_1)) {
5357 return;
5358 }
5359 int32_t serialId = GetSerialId();
5360 DataSleepInfo dataSleepInfo;
5361 dataSleepInfo.sleepEnable = 1;
5362 int32_t ret = g_rilInterface->SendDataSleepMode(SLOTID_1, serialId, dataSleepInfo);
5363 WaitFor(WAIT_TIME_SECOND_LONG);
5364 EXPECT_GT(ret, -1);
5365 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_SLEEP_MODE);
5366 }
5367
5368 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataSleepMode_V1_0200, Function | MediumTest | Level3)
5369 {
5370 if (!IsReady(SLOTID_2)) {
5371 return;
5372 }
5373 int32_t serialId = GetSerialId();
5374 DataSleepInfo dataSleepInfo;
5375 dataSleepInfo.sleepEnable = 1;
5376 int32_t ret = g_rilInterface->SendDataSleepMode(SLOTID_2, serialId, dataSleepInfo);
5377 WaitFor(WAIT_TIME_SECOND_LONG);
5378 EXPECT_GT(ret, -1);
5379 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_SLEEP_MODE);
5380 }
5381
5382 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataPerformanceMode_V1_0100, Function | MediumTest | Level3)
5383 {
5384 if (!IsReady(SLOTID_1)) {
5385 return;
5386 }
5387 int32_t serialId = GetSerialId();
5388 DataPerformanceInfo dataPerformanceInfo;
5389 dataPerformanceInfo.performanceEnable = 0;
5390 dataPerformanceInfo.enforce = 1;
5391 int32_t ret = g_rilInterface->SendDataPerformanceMode(SLOTID_1, serialId, dataPerformanceInfo);
5392 WaitFor(WAIT_TIME_SECOND_LONG);
5393 EXPECT_GT(ret, -1);
5394 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_PERFORMANCE_MODE);
5395 }
5396
5397 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataPerformanceMode_V1_0200, Function | MediumTest | Level3)
5398 {
5399 if (!IsReady(SLOTID_2)) {
5400 return;
5401 }
5402 int32_t serialId = GetSerialId();
5403 DataPerformanceInfo dataPerformanceInfo;
5404 dataPerformanceInfo.performanceEnable = 0;
5405 dataPerformanceInfo.enforce = 1;
5406 int32_t ret = g_rilInterface->SendDataPerformanceMode(SLOTID_2, serialId, dataPerformanceInfo);
5407 WaitFor(WAIT_TIME_SECOND_LONG);
5408 EXPECT_GT(ret, -1);
5409 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_PERFORMANCE_MODE);
5410 }
5411
5412 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkCapability_V1_0100, Function | MediumTest | Level3)
5413 {
5414 if (!IsReady(SLOTID_1)) {
5415 return;
5416 }
5417 int32_t serialId = GetSerialId();
5418 int32_t ret = g_rilInterface->GetLinkCapability(SLOTID_1, serialId);
5419 WaitFor(WAIT_TIME_SECOND_LONG);
5420 EXPECT_GT(ret, -1);
5421 GetBoolResult(HdiId::HREQ_DATA_GET_LINK_CAPABILITY);
5422 }
5423
5424 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkCapability_V1_0200, Function | MediumTest | Level3)
5425 {
5426 if (!IsReady(SLOTID_2)) {
5427 return;
5428 }
5429 int32_t serialId = GetSerialId();
5430 int32_t ret = g_rilInterface->GetLinkCapability(SLOTID_2, serialId);
5431 WaitFor(WAIT_TIME_SECOND_LONG);
5432 EXPECT_GT(ret, -1);
5433 GetBoolResult(HdiId::HREQ_DATA_GET_LINK_CAPABILITY);
5434 }
5435