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